infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/graphql/queries/diff/tree.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any, Optional, Union
 
-from graphene import Argument, Boolean, DateTime, Field, InputObjectType, Int, List, ObjectType, String
+from graphene import Argument, Boolean, DateTime, Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene import Enum as GrapheneEnum
 from infrahub_sdk.utils import extract_fields
 
@@ -75,7 +75,7 @@ class DiffAttribute(DiffSummaryCounts):
     last_changed_at = DateTime(required=True)
     status = Field(GrapheneDiffActionEnum, required=True)
     path_identifier = String(required=True)
-    properties = List(DiffProperty)
+    properties = List(NonNull(DiffProperty))
     contains_conflict = Boolean(required=True)
     conflict = Field(ConflictDetails, required=False)
 
@@ -88,7 +88,7 @@ class DiffSingleRelationship(DiffSummaryCounts):
     path_identifier = String(required=True)
     contains_conflict = Boolean(required=True)
     conflict = Field(ConflictDetails, required=False)
-    properties = List(DiffProperty)
+    properties = List(NonNull(DiffProperty))
 
 
 class DiffRelationship(DiffSummaryCounts):
@@ -98,7 +98,7 @@ class DiffRelationship(DiffSummaryCounts):
     cardinality = Field(GrapheneCardinalityEnum, required=True)
     status = Field(GrapheneDiffActionEnum, required=True)
     path_identifier = String(required=True)
-    elements = List(DiffSingleRelationship, required=True)
+    elements = List(NonNull(DiffSingleRelationship), required=True)
     contains_conflict = Boolean(required=True)
 
 
@@ -118,8 +118,8 @@ class DiffNode(DiffSummaryCounts):
     contains_conflict = Boolean(required=True)
     last_changed_at = DateTime(required=False)
     parent = Field(DiffNodeParent, required=False)
-    attributes = List(DiffAttribute, required=True)
-    relationships = List(DiffRelationship, required=True)
+    attributes = List(NonNull(DiffAttribute), required=True)
+    relationships = List(NonNull(DiffRelationship), required=True)
 
 
 class DiffTree(DiffSummaryCounts):
@@ -130,7 +130,7 @@ class DiffTree(DiffSummaryCounts):
     num_untracked_base_changes = Int(required=False)
     num_untracked_diff_changes = Int(required=False)
     name = String(required=False)
-    nodes = List(DiffNode)
+    nodes = List(NonNull(DiffNode))
 
 
 class DiffTreeSummary(DiffSummaryCounts):
@@ -145,10 +145,10 @@ class DiffTreeSummary(DiffSummaryCounts):
 
 class DiffTreeResolver:
     async def to_diff_tree(
-        self, enriched_diff_root: EnrichedDiffRoot, context: GraphqlContext | None = None
+        self, enriched_diff_root: EnrichedDiffRoot, graphql_context: GraphqlContext | None = None
     ) -> DiffTree:
         all_nodes = list(enriched_diff_root.nodes)
-        tree_nodes = [self.to_diff_node(enriched_node=e_node, context=context) for e_node in all_nodes]
+        tree_nodes = [self.to_diff_node(enriched_node=e_node, graphql_context=graphql_context) for e_node in all_nodes]
         name = None
         if enriched_diff_root.tracking_id and isinstance(enriched_diff_root.tracking_id, NameTrackingId):
             name = enriched_diff_root.tracking_id.name
@@ -165,21 +165,22 @@ class DiffTreeResolver:
             num_conflicts=enriched_diff_root.num_conflicts,
         )
 
-    def to_diff_node(self, enriched_node: EnrichedDiffNode, context: GraphqlContext | None = None) -> DiffNode:
+    def to_diff_node(self, enriched_node: EnrichedDiffNode, graphql_context: GraphqlContext | None = None) -> DiffNode:
         diff_attributes = [
-            self.to_diff_attribute(enriched_attribute=e_attr, context=context) for e_attr in enriched_node.attributes
+            self.to_diff_attribute(enriched_attribute=e_attr, graphql_context=graphql_context)
+            for e_attr in enriched_node.attributes
         ]
         diff_relationships = [
-            self.to_diff_relationship(enriched_relationship=e_rel, context=context)
+            self.to_diff_relationship(enriched_relationship=e_rel, graphql_context=graphql_context)
             for e_rel in enriched_node.relationships
             if e_rel.include_in_response
         ]
         conflict = None
         if enriched_node.conflict:
-            conflict = self.to_diff_conflict(enriched_conflict=enriched_node.conflict, context=context)
+            conflict = self.to_diff_conflict(enriched_conflict=enriched_node.conflict, graphql_context=graphql_context)
 
         parent = None
-        if parent_info := enriched_node.get_parent_info(context=context):
+        if parent_info := enriched_node.get_parent_info(graphql_context=graphql_context):
             parent = DiffNodeParent(
                 uuid=parent_info.node.uuid,
                 kind=parent_info.node.kind,
@@ -205,10 +206,11 @@ class DiffTreeResolver:
         )
 
     def to_diff_attribute(
-        self, enriched_attribute: EnrichedDiffAttribute, context: GraphqlContext | None = None
+        self, enriched_attribute: EnrichedDiffAttribute, graphql_context: GraphqlContext | None = None
     ) -> DiffAttribute:
         diff_properties = [
-            self.to_diff_property(enriched_property=e_prop, context=context) for e_prop in enriched_attribute.properties
+            self.to_diff_property(enriched_property=e_prop, graphql_context=graphql_context)
+            for e_prop in enriched_attribute.properties
         ]
         conflict = None
         for diff_prop in diff_properties:
@@ -230,10 +232,10 @@ class DiffTreeResolver:
         )
 
     def to_diff_relationship(
-        self, enriched_relationship: EnrichedDiffRelationship, context: GraphqlContext | None = None
+        self, enriched_relationship: EnrichedDiffRelationship, graphql_context: GraphqlContext | None = None
     ) -> DiffRelationship:
         diff_elements = [
-            self.to_diff_relationship_element(enriched_element=element, context=context)
+            self.to_diff_relationship_element(enriched_element=element, graphql_context=graphql_context)
             for element in enriched_relationship.relationships
         ]
         return DiffRelationship(
@@ -252,12 +254,14 @@ class DiffTreeResolver:
         )
 
     def to_diff_relationship_element(
-        self, enriched_element: EnrichedDiffSingleRelationship, context: GraphqlContext | None = None
+        self, enriched_element: EnrichedDiffSingleRelationship, graphql_context: GraphqlContext | None = None
     ) -> DiffSingleRelationship:
         diff_properties = [self.to_diff_property(e_prop) for e_prop in enriched_element.properties]
         conflict = None
         if enriched_element.conflict:
-            conflict = self.to_diff_conflict(enriched_conflict=enriched_element.conflict, context=context)
+            conflict = self.to_diff_conflict(
+                enriched_conflict=enriched_element.conflict, graphql_context=graphql_context
+            )
         return DiffSingleRelationship(
             last_changed_at=enriched_element.changed_at.obj,
             status=enriched_element.action,
@@ -274,11 +278,13 @@ class DiffTreeResolver:
         )
 
     def to_diff_property(
-        self, enriched_property: EnrichedDiffProperty, context: GraphqlContext | None = None
+        self, enriched_property: EnrichedDiffProperty, graphql_context: GraphqlContext | None = None
     ) -> DiffProperty:
         conflict = None
         if enriched_property.conflict:
-            conflict = self.to_diff_conflict(enriched_conflict=enriched_property.conflict, context=context)
+            conflict = self.to_diff_conflict(
+                enriched_conflict=enriched_property.conflict, graphql_context=graphql_context
+            )
         return DiffProperty(
             property_type=enriched_property.property_type.value,
             last_changed_at=enriched_property.changed_at.obj,
@@ -294,7 +300,7 @@ class DiffTreeResolver:
     def to_diff_conflict(
         self,
         enriched_conflict: EnrichedDiffConflict,
-        context: GraphqlContext | None = None,  # pylint: disable=unused-argument
+        graphql_context: GraphqlContext | None = None,  # noqa: ARG002
     ) -> ConflictDetails:
         return ConflictDetails(
             uuid=enriched_conflict.uuid,
@@ -366,10 +372,9 @@ class DiffTreeResolver:
         if diff_branch_name:
             diff_response.num_untracked_diff_changes = branch_change_map.get(diff_branch_name, 0)
 
-    # pylint: disable=unused-argument
     async def resolve(
         self,
-        root: dict,
+        root: dict,  # noqa: ARG002
         info: GraphQLResolveInfo,
         branch: str | None = None,
         name: str | None = None,
@@ -382,10 +387,10 @@ class DiffTreeResolver:
         offset: int | None = None,
     ) -> Optional[Union[list[dict[str, Any]], dict[str, Any]]]:
         component_registry = get_component_registry()
-        context: GraphqlContext = info.context
-        base_branch = await registry.get_branch(db=context.db, branch=registry.default_branch)
-        diff_branch = await registry.get_branch(db=context.db, branch=branch)
-        diff_repo = await component_registry.get_component(DiffRepository, db=context.db, branch=diff_branch)
+        graphql_context: GraphqlContext = info.context
+        base_branch = await registry.get_branch(db=graphql_context.db, branch=registry.default_branch)
+        diff_branch = await registry.get_branch(db=graphql_context.db, branch=branch)
+        diff_repo = await component_registry.get_component(DiffRepository, db=graphql_context.db, branch=diff_branch)
         branch_start_timestamp = Timestamp(diff_branch.get_branched_from())
         if from_time:
             from_timestamp = Timestamp(from_time.isoformat())
@@ -394,7 +399,7 @@ class DiffTreeResolver:
         if to_time:
             to_timestamp = Timestamp(to_time.isoformat())
         else:
-            to_timestamp = context.at or Timestamp()
+            to_timestamp = graphql_context.at or Timestamp()
 
         # Convert filters to dict and merge root_node_uuids for compatibility
         filters_dict = dict(filters or {})
@@ -428,12 +433,12 @@ class DiffTreeResolver:
             enriched_diff = enriched_diffs[0]
 
         full_fields = await extract_fields(info.field_nodes[0].selection_set)
-        diff_tree = await self.to_diff_tree(enriched_diff_root=enriched_diff, context=context)
+        diff_tree = await self.to_diff_tree(enriched_diff_root=enriched_diff, graphql_context=graphql_context)
         need_base_changes = "num_untracked_base_changes" in full_fields
         need_branch_changes = "num_untracked_diff_changes" in full_fields
         if need_base_changes or need_branch_changes:
             await self._add_untracked_fields(
-                db=context.db,
+                db=graphql_context.db,
                 diff_response=diff_tree,
                 from_time=enriched_diff.to_time,
                 base_branch_name=base_branch.name if need_base_changes else None,
@@ -441,10 +446,9 @@ class DiffTreeResolver:
             )
         return await self.to_graphql(fields=full_fields, diff_object=diff_tree)
 
-    # pylint: disable=unused-argument
     async def summary(
         self,
-        root: dict,
+        root: dict,  # noqa: ARG002
         info: GraphQLResolveInfo,
         branch: str | None = None,
         from_time: datetime | None = None,
@@ -452,10 +456,10 @@ class DiffTreeResolver:
         filters: dict | None = None,
     ) -> Optional[Union[list[dict[str, Any]], dict[str, Any]]]:
         component_registry = get_component_registry()
-        context: GraphqlContext = info.context
-        base_branch = await registry.get_branch(db=context.db, branch=registry.default_branch)
-        diff_branch = await registry.get_branch(db=context.db, branch=branch)
-        diff_repo = await component_registry.get_component(DiffRepository, db=context.db, branch=diff_branch)
+        graphql_context: GraphqlContext = info.context
+        base_branch = await registry.get_branch(db=graphql_context.db, branch=registry.default_branch)
+        diff_branch = await registry.get_branch(db=graphql_context.db, branch=branch)
+        diff_repo = await component_registry.get_component(DiffRepository, db=graphql_context.db, branch=diff_branch)
         branch_start_timestamp = Timestamp(diff_branch.get_branched_from())
         if from_time:
             from_timestamp = Timestamp(from_time.isoformat())
@@ -464,7 +468,7 @@ class DiffTreeResolver:
         if to_time:
             to_timestamp = Timestamp(to_time.isoformat())
         else:
-            to_timestamp = context.at or Timestamp()
+            to_timestamp = graphql_context.at or Timestamp()
 
         filters_dict = dict(filters or {})
 
@@ -490,7 +494,7 @@ class DiffTreeResolver:
         need_branch_changes = "num_untracked_diff_changes" in full_fields
         if need_base_changes or need_branch_changes:
             await self._add_untracked_fields(
-                db=context.db,
+                db=graphql_context.db,
                 diff_response=diff_tree_summary,
                 from_time=summary.to_time,
                 base_branch_name=base_branch.name if need_base_changes else None,
@@ -519,7 +523,6 @@ class DiffTreeQueryFilters(InputObjectType):
 DiffTreeQuery = Field(
     DiffTree,
     name=String(),
-    resolver=DiffTreeResolver().resolve,
     branch=String(),
     from_time=DateTime(),
     to_time=DateTime(),
@@ -528,14 +531,17 @@ DiffTreeQuery = Field(
     filters=DiffTreeQueryFilters(),
     limit=Int(),
     offset=Int(),
+    resolver=DiffTreeResolver().resolve,
+    required=False,
 )
 
 DiffTreeSummaryQuery = Field(
     DiffTreeSummary,
     name=String(),
-    resolver=DiffTreeResolver().summary,
     branch=String(),
     from_time=DateTime(),
     to_time=DateTime(),
     filters=DiffTreeQueryFilters(),
+    resolver=DiffTreeResolver().summary,
+    required=False,
 )

infrahub/graphql/queries/event.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from graphene import Boolean, DateTime, Field, Int, List, NonNull, ObjectType, String
+from infrahub_sdk.utils import extract_fields_first_node
+
+from infrahub.exceptions import ValidationError
+from infrahub.graphql.types.event import EventNodes
+from infrahub.task_manager.event import PrefectEvent
+from infrahub.task_manager.models import InfrahubEventFilter
+
+if TYPE_CHECKING:
+    from datetime import datetime
+
+    from graphql import GraphQLResolveInfo
+
+
+class Events(ObjectType):
+    edges = List(NonNull(EventNodes), required=True)
+    count = Int(required=True)
+
+    @staticmethod
+    async def resolve(
+        root: dict,  # noqa: ARG004
+        info: GraphQLResolveInfo,
+        limit: int = 10,
+        has_children: bool | None = None,
+        level: int | None = None,
+        offset: int | None = None,
+        account__ids: list[str] | None = None,
+        ids: list[str] | None = None,
+        branches: list[str] | None = None,
+        event_type: list[str] | None = None,
+        related_node__ids: list[str] | None = None,
+        primary_node__ids: list[str] | None = None,
+        parent__ids: list[str] | None = None,
+        since: datetime | None = None,
+        until: datetime | None = None,
+    ) -> dict[str, Any]:
+        ids = ids or []
+        if limit > 50:
+            # Prefect restricts this to 50
+            raise ValidationError(input_value="The parameter 'limit' can't be above 50")
+
+        event_filter = InfrahubEventFilter.from_filters(
+            ids=ids,
+            branches=branches,
+            account__ids=account__ids,
+            has_children=has_children,
+            event_type=event_type,
+            related_node__ids=related_node__ids,
+            primary_node__ids=primary_node__ids,
+            parent__ids=parent__ids,
+            since=since,
+            until=until,
+            level=level,
+        )
+
+        return await Events.query(
+            info=info,
+            event_filter=event_filter,
+            limit=limit,
+            offset=offset,
+        )
+
+    @classmethod
+    async def query(
+        cls,
+        info: GraphQLResolveInfo,
+        event_filter: InfrahubEventFilter,
+        limit: int,
+        offset: int | None = None,
+    ) -> dict[str, Any]:
+        fields = await extract_fields_first_node(info)
+
+        prefect_tasks = await PrefectEvent.query(
+            fields=fields,
+            event_filter=event_filter,
+            limit=limit,
+            offset=offset,
+        )
+        return {
+            "count": prefect_tasks.get("count", 0),
+            "edges": prefect_tasks.get("edges", []),
+        }
+
+
+Event = Field(
+    Events,
+    limit=Int(required=False),
+    offset=Int(required=False),
+    level=Int(required=False),
+    has_children=Boolean(required=False, description="Filter events based on if they can have children or not"),
+    event_type=List(NonNull(String), description="Filter events that match a specific type"),
+    primary_node__ids=List(
+        NonNull(String), description="Filter events where the primary node id is within indicated node ids"
+    ),
+    related_node__ids=List(
+        NonNull(String), description="Filter events where the related node ids are within indicated node ids"
+    ),
+    parent__ids=List(
+        NonNull(String), description="Search events that has any of the indicated event ids listed as parents"
+    ),
+    since=DateTime(required=False, description="Search events since this timestamp, defaults to 180 days back"),
+    until=DateTime(required=False, description="Search events until this timestamp, defaults the current time"),
+    branches=List(NonNull(String), required=False, description="Filter the query to specific branches"),
+    account__ids=List(NonNull(String), required=False, description="Filter the query to specific accounts"),
+    ids=List(NonNull(String)),
+    resolver=Events.resolve,
+    required=True,
+)

infrahub/graphql/queries/internal.py

@@ -17,10 +17,10 @@ class Info(ObjectType):
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
-        info: GraphQLResolveInfo,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
+        info: GraphQLResolveInfo,  # noqa: ARG004
     ) -> dict[str, str]:
         return {"deployment_id": str(registry.id), "version": __version__}
 
 
-InfrahubInfo = Field(Info, resolver=Info.resolve)
+InfrahubInfo = Field(Info, resolver=Info.resolve, required=True)

infrahub/graphql/queries/ipam.py

@@ -4,13 +4,14 @@ import ipaddress
 from typing import TYPE_CHECKING, Optional
 
 from graphene import Field, Int, ObjectType, String
+from netaddr import IPSet
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.manager import NodeManager
 from infrahub.core.query.ipam import get_ip_addresses, get_subnets
 from infrahub.exceptions import NodeNotFoundError, ValidationError
 from infrahub.pools.address import get_available
-from infrahub.pools.prefix import PrefixPool
+from infrahub.pools.prefix import get_next_available_prefix
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
@@ -23,18 +24,18 @@ class IPAddressGetNextAvailable(ObjectType):
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
         prefix_length: Optional[int] = None,
     ) -> dict[str, str]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        prefix = await NodeManager.get_one(id=prefix_id, db=context.db, branch=context.branch)
+        prefix = await NodeManager.get_one(id=prefix_id, db=graphql_context.db, branch=graphql_context.branch)
 
         if not prefix:
             raise NodeNotFoundError(
-                branch_name=context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
+                branch_name=graphql_context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
             )
 
         ip_prefix = ipaddress.ip_network(prefix.prefix.value)  # type: ignore[attr-defined]
@@ -43,12 +44,12 @@ class IPAddressGetNextAvailable(ObjectType):
         if not ip_prefix.prefixlen <= prefix_length <= ip_prefix.max_prefixlen:
             raise ValidationError(input_value="Invalid prefix length for current selected prefix")
 
-        namespace = await prefix.ip_namespace.get_peer(db=context.db)  # type: ignore[attr-defined]
+        namespace = await prefix.ip_namespace.get_peer(db=graphql_context.db)  # type: ignore[attr-defined]
         addresses = await get_ip_addresses(
-            db=context.db,
+            db=graphql_context.db,
             ip_prefix=ip_prefix,
             namespace=namespace,
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
 
         available = get_available(
@@ -70,33 +71,35 @@ class IPPrefixGetNextAvailable(ObjectType):
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
         prefix_length: int,
     ) -> dict[str, str]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
-        prefix = await NodeManager.get_one(id=prefix_id, db=context.db, branch=context.branch)
+        prefix = await NodeManager.get_one(id=prefix_id, db=graphql_context.db, branch=graphql_context.branch)
 
         if not prefix:
             raise NodeNotFoundError(
-                branch_name=context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
+                branch_name=graphql_context.branch.name, node_type=InfrahubKind.IPPREFIX, identifier=prefix_id
             )
 
-        namespace = await prefix.ip_namespace.get_peer(db=context.db)  # type: ignore[attr-defined]
+        namespace = await prefix.ip_namespace.get_peer(db=graphql_context.db)  # type: ignore[attr-defined]
         subnets = await get_subnets(
-            db=context.db,
+            db=graphql_context.db,
             ip_prefix=ipaddress.ip_network(prefix.prefix.value),  # type: ignore[attr-defined]
             namespace=namespace,
-            branch=context.branch,
+            branch=graphql_context.branch,
         )
 
-        pool = PrefixPool(prefix.prefix.value)  # type: ignore[attr-defined]
+        pool = IPSet([prefix.prefix.value])
         for subnet in subnets:
-            pool.reserve(subnet=str(subnet.prefix))
+            pool.remove(addr=str(subnet.prefix))
+
+        prefix_ver = ipaddress.ip_network(prefix.prefix.value).version
+        next_available = get_next_available_prefix(pool=pool, prefix_length=prefix_length, prefix_ver=prefix_ver)
 
-        next_available = pool.get(prefixlen=prefix_length)
         return {"prefix": str(next_available)}
 
 
@@ -105,6 +108,7 @@ InfrahubIPAddressGetNextAvailable = Field(
     prefix_id=String(required=True),
     prefix_length=Int(required=False),
     resolver=IPAddressGetNextAvailable.resolve,
+    required=True,
 )
 
 
@@ -113,4 +117,5 @@ InfrahubIPPrefixGetNextAvailable = Field(
     prefix_id=String(required=True),
     prefix_length=Int(required=False),
     resolver=IPPrefixGetNextAvailable.resolve,
+    required=True,
 )

infrahub/graphql/queries/relationship.py

@@ -15,30 +15,30 @@ if TYPE_CHECKING:
 
 
 class Relationships(ObjectType):
-    edges = List(RelationshipNode)
-    count = Int()
+    edges = List(of_type=NonNull(RelationshipNode), required=True)
+    count = Int(required=True)
 
     @staticmethod
     async def resolve(
-        root: dict,  # pylint: disable=unused-argument
+        root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         ids: list[str],
         limit: int = 10,
         offset: int = 0,
         excluded_namespaces: Optional[list[str]] = None,
     ) -> dict[str, Any]:
-        context: GraphqlContext = info.context
+        graphql_context: GraphqlContext = info.context
 
         fields = await extract_fields_first_node(info)
         excluded_namespaces = excluded_namespaces or []
 
         response: dict[str, Any] = {"edges": [], "count": None}
 
-        async with context.db.start_session() as db:
+        async with graphql_context.db.start_session() as db:
             query = await RelationshipGetByIdentifierQuery.init(
                 db=db,
-                branch=context.branch,
-                at=context.at,
+                branch=graphql_context.branch,
+                at=graphql_context.at,
                 identifiers=ids,
                 excluded_namespaces=excluded_namespaces,
                 limit=limit,
@@ -74,9 +74,10 @@ class Relationships(ObjectType):
 
 Relationship = Field(
     Relationships,
-    resolver=Relationships.resolve,
-    limit=Int(required=False),
-    offset=Int(required=False),
     ids=List(NonNull(String), required=True),
     excluded_namespaces=List(String),
+    limit=Int(required=False),
+    offset=Int(required=False),
+    resolver=Relationships.resolve,
+    required=True,
 )