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

infrahub/graphql/mutations/webhook.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any, Self, cast
+
+from graphene import InputObjectType, Mutation
+
+from infrahub.core.manager import NodeManager
+from infrahub.core.protocols import CoreWebhook
+from infrahub.core.schema import NodeSchema
+from infrahub.database import retry_db_transaction
+from infrahub.events.utils import get_all_infrahub_node_kind_events
+from infrahub.exceptions import ValidationError
+from infrahub.log import get_logger
+
+from .main import InfrahubMutationMixin, InfrahubMutationOptions
+
+if TYPE_CHECKING:
+    from graphql import GraphQLResolveInfo
+
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.database import InfrahubDatabase
+    from infrahub.graphql.initialization import GraphqlContext
+
+log = get_logger()
+
+
+@dataclass
+class StringValue:
+    value: str
+
+
+@dataclass
+class WebhookCreate:
+    event_type: StringValue | None = field(default=None)
+    node_kind: StringValue | None = field(default=None)
+
+
+class WebhookUpdate(WebhookCreate):
+    id: str | None = field(default=None)
+    hfid: list[str] | None = field(default=None)
+
+
+class InfrahubWebhookMutation(InfrahubMutationMixin, Mutation):
+    _meta: InfrahubMutationOptions
+
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls, schema: NodeSchema | None = None, _meta: InfrahubMutationOptions | None = None, **options: dict[str, Any]
+    ) -> None:
+        # Make sure schema is a valid NodeSchema Node Class
+        if not isinstance(schema, NodeSchema):
+            raise ValueError(f"You need to pass a valid NodeSchema in '{cls.__name__}.Meta', received '{schema}'")
+
+        if not _meta:
+            _meta = InfrahubMutationOptions(cls)
+
+        _meta.schema = schema
+
+        super().__init_subclass_with_meta__(_meta=_meta, **options)
+
+    @classmethod
+    async def mutate_create(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+
+        input_data = cast("WebhookCreate", data)
+
+        _validate_input(graphql_context=graphql_context, branch=branch, input_data=input_data)
+
+        obj, result = await super().mutate_create(info=info, data=data, branch=branch, database=database)
+
+        return obj, result
+
+    @classmethod
+    @retry_db_transaction(name="object_update")
+    async def mutate_update(
+        cls,
+        info: GraphQLResolveInfo,
+        data: InputObjectType,
+        branch: Branch,
+        database: InfrahubDatabase | None = None,
+        node: Node | None = None,
+    ) -> tuple[Node, Self]:
+        graphql_context: GraphqlContext = info.context
+
+        db = database or graphql_context.db
+
+        input_data = cast("WebhookUpdate", data)
+
+        _validate_input(graphql_context=graphql_context, branch=branch, input_data=input_data)
+
+        obj = node or await NodeManager.find_object(
+            db=db,
+            kind=cls._meta.active_schema.kind,
+            id=input_data.id,
+            hfid=input_data.hfid,
+            branch=branch,
+        )
+
+        webhook = cast(CoreWebhook, obj)
+
+        event_type = input_data.event_type.value if input_data.event_type else webhook.event_type.value.value
+        node_kind = input_data.node_kind.value if input_data.node_kind else webhook.node_kind.value
+
+        if event_type and node_kind:
+            updated_data = WebhookUpdate(
+                event_type=StringValue(value=event_type), node_kind=StringValue(value=node_kind)
+            )
+            _validate_input(graphql_context=graphql_context, branch=branch, input_data=updated_data)
+
+        try:
+            obj, result = await cls._call_mutate_update(info=info, data=data, db=db, branch=branch, obj=obj)
+        except ValidationError as exc:
+            raise ValueError(str(exc)) from exc
+
+        return obj, result
+
+
+def _validate_input(graphql_context: GraphqlContext, branch: Branch, input_data: WebhookCreate) -> None:
+    if input_data.node_kind:
+        # Validate that the requested node_kind exists, will raise an error if not
+        graphql_context.db.schema.get(name=input_data.node_kind.value, branch=branch, duplicate=False)
+
+        if input_data.event_type:
+            # If the event type is not set then all events are applicable, this will mean that some events
+            # would be filtered out, as they won't match the node.
+            if input_data.event_type.value not in get_all_infrahub_node_kind_events():
+                raise ValidationError(
+                    input_value=f"Defining a node_kind is not valid for {input_data.event_type.value} events"
+                )

infrahub/graphql/parser.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from graphql.language import (
     DirectiveNode,
@@ -172,13 +172,13 @@ class GraphQLExtractor:
         return fields
 
     async def extract_fields(
-        self, selection_set: Optional[SelectionSetNode], path: str = "/"
-    ) -> Optional[dict[str, Optional[dict]]]:
+        self, selection_set: SelectionSetNode | None, path: str = "/"
+    ) -> dict[str, dict | None] | None:
         """Extract fields and apply Directives"""
         if not selection_set:
             return None
 
-        fields: dict[str, Optional[dict]] = {}
+        fields: dict[str, dict | None] = {}
         for node in selection_set.selections:
             sub_selection_set = getattr(node, "selection_set", None)
             if isinstance(node, FieldNode):

infrahub/graphql/permissions.py

@@ -15,16 +15,7 @@ async def get_permissions(schema: MainSchemaTypes, graphql_context: GraphqlConte
     schema_objects = [schema]
     if isinstance(schema, GenericSchema):
         for node_name in schema.used_by:
-            schema_object: MainSchemaTypes
-            try:
-                schema_object = registry.schema.get_node_schema(
-                    name=node_name, branch=graphql_context.branch, duplicate=False
-                )
-            except ValueError:
-                schema_object = registry.schema.get_profile_schema(
-                    name=node_name, branch=graphql_context.branch, duplicate=False
-                )
-            schema_objects.append(schema_object)
+            schema_objects.append(registry.schema.get(name=node_name, branch=graphql_context.branch, duplicate=False))
 
     response: dict[str, Any] = {"count": len(schema_objects), "edges": []}
 

infrahub/graphql/queries/diff/tree.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from graphene import Argument, Boolean, DateTime, Field, InputObjectType, Int, List, NonNull, ObjectType, String
 from graphene import Enum as GrapheneEnum
@@ -193,7 +193,7 @@ class DiffTreeResolver:
             label=enriched_node.label,
             status=enriched_node.action,
             parent=parent,
-            last_changed_at=enriched_node.changed_at.obj if enriched_node.changed_at else None,
+            last_changed_at=enriched_node.changed_at.to_datetime() if enriched_node.changed_at else None,
             path_identifier=enriched_node.path_identifier,
             attributes=diff_attributes,
             relationships=diff_relationships,
@@ -219,7 +219,7 @@ class DiffTreeResolver:
                 diff_prop.conflict = None
         return DiffAttribute(
             name=enriched_attribute.name,
-            last_changed_at=enriched_attribute.changed_at.obj,
+            last_changed_at=enriched_attribute.changed_at.to_datetime(),
             status=enriched_attribute.action,
             path_identifier=enriched_attribute.path_identifier,
             properties=diff_properties,
@@ -241,7 +241,9 @@ class DiffTreeResolver:
         return DiffRelationship(
             name=enriched_relationship.name,
             label=enriched_relationship.label,
-            last_changed_at=enriched_relationship.changed_at.obj if enriched_relationship.changed_at else None,
+            last_changed_at=enriched_relationship.changed_at.to_datetime()
+            if enriched_relationship.changed_at
+            else None,
             status=enriched_relationship.action,
             cardinality=enriched_relationship.cardinality,
             path_identifier=enriched_relationship.path_identifier,
@@ -263,7 +265,7 @@ class DiffTreeResolver:
                 enriched_conflict=enriched_element.conflict, graphql_context=graphql_context
             )
         return DiffSingleRelationship(
-            last_changed_at=enriched_element.changed_at.obj,
+            last_changed_at=enriched_element.changed_at.to_datetime(),
             status=enriched_element.action,
             peer_id=enriched_element.peer_id,
             peer_label=enriched_element.peer_label,
@@ -287,7 +289,7 @@ class DiffTreeResolver:
             )
         return DiffProperty(
             property_type=enriched_property.property_type.value,
-            last_changed_at=enriched_property.changed_at.obj,
+            last_changed_at=enriched_property.changed_at.to_datetime(),
             previous_value=enriched_property.previous_value,
             new_value=enriched_property.new_value,
             previous_label=enriched_property.previous_label,
@@ -306,13 +308,13 @@ class DiffTreeResolver:
             uuid=enriched_conflict.uuid,
             base_branch_action=enriched_conflict.base_branch_action,
             base_branch_value=enriched_conflict.base_branch_value,
-            base_branch_changed_at=enriched_conflict.base_branch_changed_at.obj
+            base_branch_changed_at=enriched_conflict.base_branch_changed_at.to_datetime()
             if enriched_conflict.base_branch_changed_at
             else None,
             base_branch_label=enriched_conflict.base_branch_label,
             diff_branch_action=enriched_conflict.diff_branch_action,
             diff_branch_value=enriched_conflict.diff_branch_value,
-            diff_branch_changed_at=enriched_conflict.diff_branch_changed_at.obj
+            diff_branch_changed_at=enriched_conflict.diff_branch_changed_at.to_datetime()
             if enriched_conflict.diff_branch_changed_at
             else None,
             diff_branch_label=enriched_conflict.diff_branch_label,
@@ -322,7 +324,7 @@ class DiffTreeResolver:
 
     async def to_graphql(
         self, fields: dict[str, dict], diff_object: Any | None
-    ) -> Optional[Union[list[dict[str, Any]], dict[str, Any]]]:
+    ) -> list[dict[str, Any]] | dict[str, Any] | None:
         if diff_object is None:
             return None
         if isinstance(diff_object, list):
@@ -385,7 +387,7 @@ class DiffTreeResolver:
         root_node_uuids: list[str] | None = None,
         limit: int | None = None,
         offset: int | None = None,
-    ) -> Optional[Union[list[dict[str, Any]], dict[str, Any]]]:
+    ) -> list[dict[str, Any]] | dict[str, Any] | None:
         component_registry = get_component_registry()
         graphql_context: GraphqlContext = info.context
         base_branch = await registry.get_branch(db=graphql_context.db, branch=registry.default_branch)
@@ -426,7 +428,10 @@ class DiffTreeResolver:
             # take the one with the longest duration that covers multiple branches
             enriched_diff = sorted(
                 enriched_diffs,
-                key=lambda d: (d.base_branch_name != d.diff_branch_name, d.to_time.obj - d.from_time.obj),
+                key=lambda d: (
+                    d.base_branch_name != d.diff_branch_name,
+                    d.to_time.to_datetime() - d.from_time.to_datetime(),
+                ),
                 reverse=True,
             )[0]
         else:
@@ -454,7 +459,7 @@ class DiffTreeResolver:
         from_time: datetime | None = None,
         to_time: datetime | None = None,
         filters: dict | None = None,
-    ) -> Optional[Union[list[dict[str, Any]], dict[str, Any]]]:
+    ) -> list[dict[str, Any]] | dict[str, Any] | None:
         component_registry = get_component_registry()
         graphql_context: GraphqlContext = info.context
         base_branch = await registry.get_branch(db=graphql_context.db, branch=registry.default_branch)
@@ -485,8 +490,8 @@ class DiffTreeResolver:
         diff_tree_summary = DiffTreeSummary(
             base_branch=base_branch.name,
             diff_branch=diff_branch.name,
-            from_time=summary.from_time.obj,
-            to_time=summary.to_time.obj,
+            from_time=summary.from_time.to_datetime(),
+            to_time=summary.to_time.to_datetime(),
             **summary.model_dump(exclude={"from_time", "to_time"}),
         )
         full_fields = await extract_fields(info.field_nodes[0].selection_set)

infrahub/graphql/queries/event.py

@@ -2,11 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, DateTime, Field, Int, List, NonNull, ObjectType, String
+from graphene import Argument, 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.graphql.types.event import EventNodes, EventTypeFilter
 from infrahub.task_manager.event import PrefectEvent
 from infrahub.task_manager.models import InfrahubEventFilter
 
@@ -32,6 +32,7 @@ class Events(ObjectType):
         ids: list[str] | None = None,
         branches: list[str] | None = None,
         event_type: list[str] | None = None,
+        event_type_filter: dict[str, Any] | None = None,
         related_node__ids: list[str] | None = None,
         primary_node__ids: list[str] | None = None,
         parent__ids: list[str] | None = None,
@@ -49,6 +50,7 @@ class Events(ObjectType):
             account__ids=account__ids,
             has_children=has_children,
             event_type=event_type,
+            event_type_filter=event_type_filter,
             related_node__ids=related_node__ids,
             primary_node__ids=primary_node__ids,
             parent__ids=parent__ids,
@@ -93,6 +95,7 @@ Event = Field(
     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"),
+    event_type_filter=Argument(EventTypeFilter, required=False, description="Filters specific to a given event_type"),
     primary_node__ids=List(
         NonNull(String), description="Filter events where the primary node id is within indicated node ids"
     ),

infrahub/graphql/queries/ipam.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from graphene import Field, Int, ObjectType, String
 from netaddr import IPSet
@@ -27,7 +27,7 @@ class IPAddressGetNextAvailable(ObjectType):
         root: dict,  # noqa: ARG004
         info: GraphQLResolveInfo,
         prefix_id: str,
-        prefix_length: Optional[int] = None,
+        prefix_length: int | None = None,
     ) -> dict[str, str]:
         graphql_context: GraphqlContext = info.context
 

infrahub/graphql/queries/relationship.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from graphene import Field, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
@@ -25,7 +25,7 @@ class Relationships(ObjectType):
         ids: list[str],
         limit: int = 10,
         offset: int = 0,
-        excluded_namespaces: Optional[list[str]] = None,
+        excluded_namespaces: list[str] | None = None,
     ) -> dict[str, Any]:
         graphql_context: GraphqlContext = info.context
 

infrahub/graphql/queries/search.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import ipaddress
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from graphene import Boolean, Field, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node, is_valid_uuid
@@ -110,7 +110,7 @@ async def search_resolver(
     fields = await extract_fields_first_node(info)
 
     if is_valid_uuid(q):
-        matching: Optional[CoreNode] = await NodeManager.get_one(
+        matching: CoreNode | None = await NodeManager.get_one(
             db=graphql_context.db, branch=graphql_context.branch, at=graphql_context.at, id=q
         )
         if matching:

infrahub/graphql/resolvers/many_relationship.py

@@ -0,0 +1,264 @@
+from typing import TYPE_CHECKING, Any
+
+from graphql import GraphQLResolveInfo
+from infrahub_sdk.utils import deep_merge_dict, extract_fields
+
+from infrahub.core.branch.models import Branch
+from infrahub.core.constants import BranchSupportType, RelationshipHierarchyDirection
+from infrahub.core.manager import NodeManager
+from infrahub.core.query.node import NodeGetHierarchyQuery
+from infrahub.core.schema.node_schema import NodeSchema
+from infrahub.core.schema.relationship_schema import RelationshipSchema
+from infrahub.core.timestamp import Timestamp
+from infrahub.database import InfrahubDatabase
+
+from ..loaders.peers import PeerRelationshipsDataLoader, QueryPeerParams
+from ..types import RELATIONS_PROPERTY_MAP, RELATIONS_PROPERTY_MAP_REVERSED
+
+if TYPE_CHECKING:
+    from infrahub.core.schema import MainSchemaTypes
+
+    from ..initialization import GraphqlContext
+
+
+class ManyRelationshipResolver:
+    def __init__(self) -> None:
+        self._data_loader_instances: dict[QueryPeerParams, PeerRelationshipsDataLoader] = {}
+
+    async def get_descendant_ids(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        at: Timestamp | None,
+        parent_id: str,
+        node_schema: NodeSchema,
+    ) -> list[str]:
+        async with db.start_session() as dbs:
+            query = await NodeGetHierarchyQuery.init(
+                db=dbs,
+                direction=RelationshipHierarchyDirection.DESCENDANTS,
+                node_id=parent_id,
+                node_schema=node_schema,
+                at=at,
+                branch=branch,
+            )
+            await query.execute(db=dbs)
+        return list(query.get_peer_ids())
+
+    async def get_peer_count(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        at: Timestamp | None,
+        ids: list[str],
+        source_kind: str,
+        rel_schema: RelationshipSchema,
+        filters: dict[str, Any],
+    ) -> int:
+        async with db.start_session() as dbs:
+            return await NodeManager.count_peers(
+                db=dbs,
+                ids=ids,
+                source_kind=source_kind,
+                schema=rel_schema,
+                filters=filters,
+                at=at,
+                branch=branch,
+                branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
+            )
+
+    async def resolve(
+        self,
+        parent: dict,
+        info: GraphQLResolveInfo,
+        include_descendants: bool = False,
+        offset: int | None = None,
+        limit: int | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        """Resolver for relationships of cardinality=one for Edged responses
+
+        This resolver is used for paginated responses and as such we redefined the requested
+        fields by only reusing information below the 'node' key.
+        """
+        # Extract the InfraHub schema by inspecting the GQL Schema
+
+        node_schema: MainSchemaTypes = info.parent_type.graphene_type._meta.schema  # type: ignore[attr-defined]
+
+        graphql_context: GraphqlContext = info.context
+
+        # Extract the name of the fields in the GQL query
+        fields = await extract_fields(info.field_nodes[0].selection_set)
+        edges = fields.get("edges", {})
+        node_fields = edges.get("node", {})
+        property_fields = edges.get("properties", {})
+        for key, value in property_fields.items():
+            mapped_name = RELATIONS_PROPERTY_MAP[key]
+            node_fields[mapped_name] = value
+
+        filters = {
+            f"{info.field_name}__{key}": value
+            for key, value in kwargs.items()
+            if "__" in key and value or key in ["id", "ids"]
+        }
+
+        response: dict[str, Any] = {"edges": [], "count": None}
+
+        # Extract the schema of the node on the other end of the relationship from the GQL Schema
+        node_rel = node_schema.get_relationship(info.field_name)
+        source_kind = node_schema.kind
+        ids = [parent["id"]]
+        if isinstance(node_schema, NodeSchema):
+            if node_schema.hierarchy:
+                source_kind = node_schema.hierarchy
+
+            if include_descendants:
+                descendant_ids = await self.get_descendant_ids(
+                    db=graphql_context.db,
+                    branch=graphql_context.branch,
+                    at=graphql_context.at,
+                    parent_id=ids[0],
+                    node_schema=node_schema,
+                )
+                ids.extend(descendant_ids)
+
+        if "count" in fields:
+            peer_count = await self.get_peer_count(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                at=graphql_context.at,
+                ids=ids,
+                source_kind=source_kind,
+                rel_schema=node_rel,
+                filters=filters,
+            )
+            response["count"] = peer_count
+
+        if not node_fields:
+            return response
+
+        if offset or limit:
+            node_graph = await self._get_entities_simple(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                ids=ids,
+                at=graphql_context.at,
+                related_node_ids=graphql_context.related_node_ids,
+                source_kind=source_kind,
+                rel_schema=node_rel,
+                filters=filters,
+                node_fields=node_fields,
+                offset=offset,
+                limit=limit,
+            )
+        else:
+            node_graph = await self._get_entities_with_data_loader(
+                db=graphql_context.db,
+                branch=graphql_context.branch,
+                ids=ids,
+                at=graphql_context.at,
+                related_node_ids=graphql_context.related_node_ids,
+                source_kind=source_kind,
+                rel_schema=node_rel,
+                filters=filters,
+                node_fields=node_fields,
+            )
+
+        if not node_graph:
+            return response
+
+        entries = []
+        for node in node_graph:
+            entry: dict[str, dict[str, Any]] = {"node": {}, "properties": {}}
+            for key, mapped in RELATIONS_PROPERTY_MAP_REVERSED.items():
+                value = node.pop(key, None)
+                if value:
+                    entry["properties"][mapped] = value
+            entry["node"] = node
+            entries.append(entry)
+
+        response["edges"] = entries
+        return response
+
+    async def _get_entities_simple(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        ids: list[str],
+        at: Timestamp | None,
+        related_node_ids: set[str] | None,
+        source_kind: str,
+        rel_schema: RelationshipSchema,
+        filters: dict[str, Any],
+        node_fields: dict[str, Any],
+        offset: int | None = None,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]] | None:
+        async with db.start_session() as dbs:
+            objs = await NodeManager.query_peers(
+                db=dbs,
+                ids=ids,
+                source_kind=source_kind,
+                schema=rel_schema,
+                filters=filters,
+                fields=node_fields,
+                offset=offset,
+                limit=limit,
+                at=at,
+                branch=branch,
+                branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
+                fetch_peers=True,
+            )
+            if not objs:
+                return None
+            return [await obj.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids) for obj in objs]
+
+    async def _get_entities_with_data_loader(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        ids: list[str],
+        at: Timestamp | None,
+        related_node_ids: set[str] | None,
+        source_kind: str,
+        rel_schema: RelationshipSchema,
+        filters: dict[str, Any],
+        node_fields: dict[str, Any],
+    ) -> list[dict[str, Any]] | None:
+        if node_fields and "display_label" in node_fields:
+            schema_branch = db.schema.get_schema_branch(name=branch.name)
+            display_label_fields = schema_branch.generate_fields_for_display_label(name=rel_schema.peer)
+            if display_label_fields:
+                node_fields = deep_merge_dict(dicta=node_fields, dictb=display_label_fields)
+
+        if node_fields and "hfid" in node_fields:
+            peer_schema = db.schema.get(name=rel_schema.peer, branch=branch, duplicate=False)
+            hfid_fields = peer_schema.generate_fields_for_hfid()
+            if hfid_fields:
+                node_fields = deep_merge_dict(dicta=node_fields, dictb=hfid_fields)
+
+        query_params = QueryPeerParams(
+            branch=branch,
+            source_kind=source_kind,
+            schema=rel_schema,
+            filters=filters,
+            fields=node_fields,
+            at=at,
+            branch_agnostic=rel_schema.branch is BranchSupportType.AGNOSTIC,
+        )
+        if query_params in self._data_loader_instances:
+            loader = self._data_loader_instances[query_params]
+        else:
+            loader = PeerRelationshipsDataLoader(db=db, query_params=query_params)
+            self._data_loader_instances[query_params] = loader
+        all_peer_rels = []
+        for node_id in ids:
+            node_peer_rels = await loader.load(key=node_id)
+            all_peer_rels.extend(node_peer_rels)
+        if not all_peer_rels:
+            return None
+        async with db.start_session() as dbs:
+            return [
+                await obj.to_graphql(db=dbs, fields=node_fields, related_node_ids=related_node_ids)
+                for obj in all_peer_rels
+            ]