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