diff --git a/swh/graphql/app.py b/swh/graphql/app.py
index 059867e..3bbae03 100644
--- a/swh/graphql/app.py
+++ b/swh/graphql/app.py
@@ -1,20 +1,20 @@
 from ariadne import gql, load_schema_from_path, make_executable_schema
 
 from .resolvers import resolvers, scalars
 
 type_defs = gql(load_schema_from_path("swh/graphql/schema/schema.graphql"))
 
 schema = make_executable_schema(
     type_defs,
     resolvers.query,
     resolvers.origin,
     resolvers.visit,
-    resolvers.visitstatus,
+    resolvers.visit_status,
     resolvers.snapshot,
-    resolvers.branch,
-    resolvers.target,
+    resolvers.snapshot_branch,
+    resolvers.branch_target,
     scalars.datetime_scalar,
     scalars.swhid_scalar,
     scalars.binary_text_scalar,
     scalars.datetimezone_scalar,
 )
diff --git a/swh/graphql/resolvers/resolvers.py b/swh/graphql/resolvers/resolvers.py
index c6e7780..c16a312 100644
--- a/swh/graphql/resolvers/resolvers.py
+++ b/swh/graphql/resolvers/resolvers.py
@@ -1,114 +1,114 @@
 """
 High level resolvers
 Any schema attribute can be resolved by any of the following ways
 and in the following priority order
 - In this module using an annotation  (eg: @visitstatus.field("snapshot"))
 - As a property in the Node object (eg: resolvers.visit.OriginVisitNode.id)
 - As an attribute/item in the object/dict returned by the backend (eg: Origin.url)
 """
 from ariadne import ObjectType, UnionType
 
 from .resolver_factory import get_connection_resolver, get_node_resolver
 
 query = ObjectType("Query")
 origin = ObjectType("Origin")
 visit = ObjectType("Visit")
-visitstatus = ObjectType("VisitStatus")
+visit_status = ObjectType("VisitStatus")
 snapshot = ObjectType("Snapshot")
-branch = ObjectType("Branch")
+snapshot_branch = ObjectType("Branch")
 
-target = UnionType("BranchTarget")
+branch_target = UnionType("BranchTarget")
 
 # Node resolvers
 # A node resolver can return a node object or a data structure
 
 
 @query.field("origin")
 def origin_resolver(obj, info, **kw):
     """
     """
     resolver = get_node_resolver("origin")
     return resolver(obj, info, **kw)()
 
 
 @query.field("visit")
 def visit_resolver(obj, info, **kw):
     """
     """
     resolver = get_node_resolver("visit")
     return resolver(obj, info, **kw)()
 
 
 @query.field("snapshot")
 def snapshot_resolver(obj, info, **kw):
     """
     """
     resolver = get_node_resolver("snapshot")
     return resolver(obj, info, **kw)()
 
 
-@visitstatus.field("snapshot")
-def visit_snapshot(obj, info, **kw):
+@visit_status.field("snapshot")
+def visit_snapshot_resolver(obj, info, **kw):
     resolver = get_node_resolver("visit-snapshot")
     return resolver(obj, info, **kw)()
 
 
-@branch.field("target")
-def branch_target(obj, info, **kw):
+@snapshot_branch.field("target")
+def snapshot_branch_target_resolver(obj, info, **kw):
     """
-    Branch target can be a revision or a release
+    Snapshot branch target can be a revision or a release
     """
     resolver_type = f"branch-{obj.type}"
     resolver = get_node_resolver(resolver_type)
     return resolver(obj, info, **kw)()
 
 
 @query.field("revision")
 def revision_resolver(obj, info, **kw):
     resolver = get_node_resolver("revision")
     return resolver(obj, info, **kw)()
 
 
 @query.field("release")
 def release_resolver(obj, info, **kw):
     resolver = get_node_resolver("release")
     return resolver(obj, info, **kw)()
 
 
 # Connection resolvers
 # A connection resolver will return a sub class of BaseConnection
 
 
 @query.field("origins")
 def origins_resolver(obj, info, **kw):
     resolver = get_connection_resolver("origins")
     return resolver(obj, info, **kw)()
 
 
 @origin.field("visits")
 def visits_resolver(obj, info, **kw):
     resolver = get_connection_resolver("origin-visits")
     return resolver(obj, info, **kw)()
 
 
 @visit.field("status")
 def visitstatus_resolver(obj, info, **kw):
     resolver = get_connection_resolver("visit-status")
     return resolver(obj, info, **kw)()
 
 
 @snapshot.field("branches")
-def snapshot_branches(obj, info, **kw):
+def snapshot_branches_resolver(obj, info, **kw):
     resolver = get_connection_resolver("snapshot-branches")
     return resolver(obj, info, **kw)()
 
 
 # Any other type of resolver
 
 
-@target.type_resolver
+@branch_target.type_resolver
 def union_resolver(obj, *_):
     """
     Generic resolver for all the union types
     """
     return obj.is_type_of()
diff --git a/swh/graphql/resolvers/snapshot.py b/swh/graphql/resolvers/snapshot.py
index 6d210dd..e609b54 100644
--- a/swh/graphql/resolvers/snapshot.py
+++ b/swh/graphql/resolvers/snapshot.py
@@ -1,43 +1,43 @@
 from swh.graphql.backends import archive
 from swh.graphql.utils import utils
 
 from .base_node import BaseNode
 
 
 class BaseSnapshotNode(BaseNode):
     def _get_snapshot_by_id(self, snapshot_id):
         return archive.Archive().get_snapshot(snapshot_id)
 
 
 class SnapshotNode(BaseSnapshotNode):
     """
     For directly accessing a snapshot with swhid
     """
 
     def _get_node_data(self):
         """
         """
         # FIXME, use methods from SWH core
         snapshot_id = utils.str_to_swid(self.kwargs.get("SWHId"))
         return self._get_snapshot_by_id(snapshot_id)
 
 
-class VisitSnapshotNode(BaseNode):
+class VisitSnapshotNode(BaseSnapshotNode):
     """
     For accessing a snapshot from a visitstatus type
     """
 
     def _get_node_data(self):
         """
         self.obj is visitstatus here
         snapshot swhid is avaialbe in the parent (self.obj)
         """
         return self._get_snapshot_by_id(self.obj.snapshot)
 
 
 # class SnapshotConnection(BaseConnection):
 #     """
 #     To get all the snapshots under an origin
 #     """
 
 #     _node_class = SnapshotNode