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

infrahub/core/diff/branch_differ.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import asyncio
 from collections import defaultdict
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING
 
 from typing_extensions import Self
 
@@ -35,12 +35,12 @@ class BranchDiffer:
     def __init__(
         self,
         branch: Branch,
-        origin_branch: Optional[Branch] = None,
+        origin_branch: Branch | None = None,
         branch_only: bool = False,
-        diff_from: Optional[Union[str, Timestamp]] = None,
-        diff_to: Optional[Union[str, Timestamp]] = None,
-        db: Optional[InfrahubDatabase] = None,
-        service: Optional[InfrahubServices] = None,
+        diff_from: str | Timestamp | None = None,
+        diff_to: str | Timestamp | None = None,
+        db: InfrahubDatabase | None = None,
+        service: InfrahubServices | None = None,
     ):
         """_summary_
 
@@ -81,7 +81,7 @@ class BranchDiffer:
 
         # Results organized by Branch
         self._results: dict[str, dict] = defaultdict(lambda: {"nodes": {}, "rels": defaultdict(dict), "files": {}})
-        self._calculated_diff_files_at: Optional[Timestamp] = None
+        self._calculated_diff_files_at: Timestamp | None = None
 
     @property
     def service(self) -> InfrahubServices:
@@ -101,9 +101,9 @@ class BranchDiffer:
         db: InfrahubDatabase,
         branch: Branch,
         branch_only: bool = False,
-        diff_from: Optional[Union[str, Timestamp]] = None,
-        diff_to: Optional[Union[str, Timestamp]] = None,
-        service: Optional[InfrahubServices] = None,
+        diff_from: str | Timestamp | None = None,
+        diff_to: str | Timestamp | None = None,
+        service: InfrahubServices | None = None,
     ) -> Self:
         origin_branch = branch.get_origin_branch()
 

infrahub/core/diff/enricher/cardinality_one.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any
 from infrahub.core.constants import NULL_VALUE, DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import (
     CalculatedDiffs,
@@ -16,6 +17,8 @@ from .interface import DiffEnricherInterface
 if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
 
+log = get_logger()
+
 
 class DiffCardinalityOneEnricher(DiffEnricherInterface):
     """Clean up diffs for cardinality=one relationships to make them cleaner and more intuitive
@@ -34,6 +37,7 @@ class DiffCardinalityOneEnricher(DiffEnricherInterface):
 
     async def enrich(self, enriched_diff_root: EnrichedDiffRoot, calculated_diffs: CalculatedDiffs) -> None:  # noqa: ARG002
         self._node_schema_map = {}
+        log.info("Beginning cardinality-one diff enrichment...")
         for diff_node in enriched_diff_root.nodes:
             for relationship_group in diff_node.relationships:
                 if (
@@ -41,6 +45,7 @@ class DiffCardinalityOneEnricher(DiffEnricherInterface):
                     and len(relationship_group.relationships) > 0
                 ):
                     self.consolidate_cardinality_one_diff_elements(diff_relationship=relationship_group)
+        log.info("Cardinality-one diff enrichment complete.")
 
     def _determine_action(self, previous_value: Any, new_value: Any) -> DiffAction:
         if previous_value == new_value:

infrahub/core/diff/enricher/hierarchy.py

@@ -7,19 +7,24 @@ from infrahub.core.query.node import NodeGetHierarchyQuery
 from infrahub.core.query.relationship import RelationshipGetPeerQuery, RelationshipPeerData
 from infrahub.core.schema import ProfileSchema, TemplateSchema
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import (
     CalculatedDiffs,
     EnrichedDiffRoot,
 )
+from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 
 class DiffHierarchyEnricher(DiffEnricherInterface):
     """Add hierarchy and parent/component nodes to diff even if the higher-level nodes are unchanged"""
 
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase, parent_adder: DiffParentNodeAdder):
         self.db = db
+        self.parent_adder = parent_adder
 
     async def enrich(
         self,
@@ -30,6 +35,8 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
         # - A node has a relationship of kind parent
         # - A node is part of a hierarchy
 
+        log.info("Beginning hierarchical diff enrichment...")
+        self.parent_adder.initialize(enriched_diff_root=enriched_diff_root)
         node_rel_parent_map: dict[str, list[str]] = defaultdict(list)
         node_hierarchy_map: dict[str, list[str]] = defaultdict(list)
 
@@ -55,6 +62,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         await self._enrich_nodes_with_parent(enriched_diff_root=enriched_diff_root, node_map=node_rel_parent_map)
         await self._enrich_hierarchical_nodes(enriched_diff_root=enriched_diff_root, node_map=node_hierarchy_map)
+        log.info("Hierarchical diff enrichment complete.")
 
     async def _enrich_hierarchical_nodes(
         self,
@@ -65,6 +73,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         # Retrieve the ID of all ancestors
         for kind, node_ids in node_map.items():
+            log.info(f"Beginning hierarchy enrichment for {kind} node, num_nodes={len(node_ids)}...")
             hierarchy_schema = self.db.schema.get(
                 name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
@@ -89,7 +98,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
                 current_node = node
                 for ancestor in ancestors:
-                    parent = enriched_diff_root.add_parent(
+                    parent_request = ParentNodeAddRequest(
                         node_id=current_node.uuid,
                         parent_id=str(ancestor.uuid),
                         parent_kind=ancestor.kind,
@@ -99,6 +108,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                         parent_rel_cardinality=parent_rel.cardinality,
                         parent_rel_label=parent_rel.label or "",
                     )
+                    parent = self.parent_adder.add_parent(parent_request=parent_request)
 
                     current_node = parent
 
@@ -116,6 +126,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         # Query the UUID of the parent
         for kind, ids in node_map.items():
+            log.info(f"Beginning parent enrichment for {kind} node, num_nodes={len(ids)}...")
             schema_node = self.db.schema.get(name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False)
 
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
@@ -140,15 +151,16 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
         # Check if the parent are already present
         # If parent is already in the list of node we need to add a relationship
         # If parent is not in the list of node, we need to add it
+        diff_node_map = enriched_diff_root.get_node_map(node_uuids=set(parent_peers.keys()))
         for node_id, peer_parent in parent_peers.items():
             # TODO check if we can optimize this part to avoid querying this multiple times
-            node = enriched_diff_root.get_node(node_uuid=node_id)
+            node = diff_node_map[node_id]
             schema_node = self.db.schema.get(
                 name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
 
-            enriched_diff_root.add_parent(
+            parent_request = ParentNodeAddRequest(
                 node_id=node.uuid,
                 parent_id=str(peer_parent.peer_id),
                 parent_kind=peer_parent.peer_kind,
@@ -158,6 +170,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                 parent_rel_cardinality=parent_rel.cardinality,
                 parent_rel_label=parent_rel.label or "",
             )
+            self.parent_adder.add_parent(parent_request=parent_request)
 
         if node_parent_with_parent_map:
             await self._enrich_nodes_with_parent(

infrahub/core/diff/enricher/labels.py

@@ -6,6 +6,7 @@ from infrahub.core.constants import DiffAction
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.query.node import NodeGetKindQuery
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import (
     CalculatedDiffs,
@@ -17,6 +18,8 @@ from ..model.path import (
 from ..payload_builder import get_display_labels
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 PROPERTY_TYPES_WITH_LABELS = {DatabaseEdgeType.IS_RELATED, DatabaseEdgeType.HAS_OWNER, DatabaseEdgeType.HAS_SOURCE}
 
 
@@ -194,6 +197,7 @@ class DiffLabelsEnricher(DiffEnricherInterface):
         calculated_diffs: CalculatedDiffs | None = None,  # noqa: ARG002
         conflicts_only: bool = False,
     ) -> None:
+        log.info("Beginning display labels diff enrichment...")
         self._base_branch_name = enriched_diff_root.base_branch_name
         self._diff_branch_name = enriched_diff_root.diff_branch_name
         self._conflicts_only = conflicts_only
@@ -214,3 +218,4 @@ class DiffLabelsEnricher(DiffEnricherInterface):
             ...
 
         self._update_relationship_labels(enriched_diff=enriched_diff_root)
+        log.info("Display labels diff enrichment complete.")

infrahub/core/diff/enricher/path_identifier.py

@@ -1,10 +1,13 @@
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import CalculatedDiffs, EnrichedDiffRoot
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 
 class DiffPathIdentifierEnricher(DiffEnricherInterface):
     """Add path identifiers to every element in the diff"""
@@ -62,3 +65,4 @@ class DiffPathIdentifierEnricher(DiffEnricherInterface):
                         relationship_property_path = relationship_element_path.model_copy()
                         relationship_property_path.property_name = relationship_property.property_type.value
                         relationship_property.path_identifier = relationship_property_path.get_path(with_peer=False)
+        log.info("Path identifier diff enrichment complete.")

infrahub/core/diff/ipam_diff_parser.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass
-from typing import Optional
 
 from infrahub.core.constants import DiffAction
 from infrahub.core.constants.database import DatabaseEdgeType
@@ -18,8 +17,8 @@ class ChangedIpamNodeDetails:
     node_uuid: str
     is_address: bool
     is_delete: bool
-    namespace_id: Optional[str]
-    ip_value: Optional[str]
+    namespace_id: str | None
+    ip_value: str | None
 
 
 class IpamDiffParser:
@@ -142,7 +141,7 @@ class IpamDiffParser:
             uuids_missing_data=uuids_missing_data,
         )
 
-    def _get_ip_value(self, node_diff: EnrichedDiffNode) -> Optional[str]:
+    def _get_ip_value(self, node_diff: EnrichedDiffNode) -> str | None:
         ip_attr_diff = None
         for diff_attr in node_diff.attributes:
             if diff_attr.name in {"prefix", "address"}:
@@ -155,7 +154,7 @@ class IpamDiffParser:
                 return diff_property.new_value or diff_property.previous_value
         return None
 
-    def _get_namespace_id(self, node_diff: EnrichedDiffNode) -> Optional[str]:
+    def _get_namespace_id(self, node_diff: EnrichedDiffNode) -> str | None:
         namespace_rel = None
         for diff_rel in node_diff.relationships:
             if diff_rel.name == "ip_namespace":

infrahub/core/diff/model/diff.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 
@@ -46,8 +46,8 @@ class BaseDiffElement(BaseModel):
 
 
 class ValueElement(BaseDiffElement):
-    previous: Optional[Any] = None
-    new: Optional[Any] = None
+    previous: Any | None = None
+    new: Any | None = None
 
     def __hash__(self) -> int:
         return hash(type(self))
@@ -57,12 +57,12 @@ class PropertyDiffElement(BaseDiffElement):
     branch: str
     type: str
     action: DiffAction
-    path: Optional[str] = None
+    path: str | None = None
     db_id: str = Field(exclude=True)
     rel_id: str = Field(exclude=True)
-    origin_rel_id: Optional[str] = Field(None, exclude=True)
-    value: Optional[ValueElement] = None
-    changed_at: Optional[Timestamp] = None
+    origin_rel_id: str | None = Field(None, exclude=True)
+    value: ValueElement | None = None
+    changed_at: Timestamp | None = None
 
 
 class NodeAttributeDiffElement(BaseDiffElement):
@@ -72,28 +72,28 @@ class NodeAttributeDiffElement(BaseDiffElement):
     action: DiffAction
     db_id: str = Field(exclude=True)
     rel_id: str = Field(exclude=True)
-    origin_rel_id: Optional[str] = Field(None, exclude=True)
-    changed_at: Optional[Timestamp] = None
+    origin_rel_id: str | None = Field(None, exclude=True)
+    changed_at: Timestamp | None = None
     properties: dict[str, PropertyDiffElement]
 
 
 class NodeDiffElement(BaseDiffElement):
-    branch: Optional[str] = None
+    branch: str | None = None
     labels: list[str]
     kind: str
     id: str
     path: str
     action: DiffAction
     db_id: str = Field(exclude=True)
-    rel_id: Optional[str] = Field(None, exclude=True)
-    changed_at: Optional[Timestamp] = None
+    rel_id: str | None = Field(None, exclude=True)
+    changed_at: Timestamp | None = None
     attributes: dict[str, NodeAttributeDiffElement] = Field(default_factory=dict)
 
 
 class RelationshipEdgeNodeDiffElement(BaseDiffElement):
     id: str
-    db_id: Optional[str] = Field(None, exclude=True)
-    rel_id: Optional[str] = Field(None, exclude=True)
+    db_id: str | None = Field(None, exclude=True)
+    rel_id: str | None = Field(None, exclude=True)
     labels: list[str]
     kind: str
 
@@ -106,11 +106,11 @@ class RelationshipDiffElement(BaseDiffElement):
     action: DiffAction
     nodes: dict[str, RelationshipEdgeNodeDiffElement]
     properties: dict[str, PropertyDiffElement]
-    changed_at: Optional[Timestamp] = None
+    changed_at: Timestamp | None = None
     paths: list[str]
     conflict_paths: list[str]
 
-    def get_node_id_by_kind(self, kind: str) -> Optional[str]:
+    def get_node_id_by_kind(self, kind: str) -> str | None:
         ids = [rel.id for rel in self.nodes.values() if rel.kind == kind]
         if ids:
             return ids[0]
@@ -149,11 +149,11 @@ class ModifiedPath(BaseModel):
     node_id: str
     path_type: PathType
     kind: str
-    element_name: Optional[str] = None
-    property_name: Optional[str] = None
-    peer_id: Optional[str] = None
+    element_name: str | None = None
+    property_name: str | None = None
+    peer_id: str | None = None
     action: DiffAction
-    change: Optional[ValueElement] = None
+    change: ValueElement | None = None
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, ModifiedPath):
@@ -248,7 +248,7 @@ class DataConflict(ObjectConflict):
     conflict_path: str
     path: str
     path_type: PathType
-    property_name: Optional[str] = None
+    property_name: str | None = None
     change_type: str
     changes: list[BranchChanges] = Field(default_factory=list)
 
@@ -311,7 +311,7 @@ class BranchDiffFile(BaseModel):
 class BranchDiffRepository(BaseModel):
     branch: str
     id: str
-    display_name: Optional[str] = None
+    display_name: str | None = None
     commit_from: str
     commit_to: str
     files: list[BranchDiffFile] = Field(default_factory=list)
@@ -325,14 +325,14 @@ class BranchDiffArtifactStorage(BaseModel):
 class ArtifactTarget(BaseModel):
     id: str
     kind: str
-    display_label: Optional[str] = None
+    display_label: str | None = None
 
 
 class BranchDiffArtifact(BaseModel):
     branch: str
     id: str
-    display_label: Optional[str] = None
+    display_label: str | None = None
     action: DiffAction
-    target: Optional[ArtifactTarget] = None
-    item_new: Optional[BranchDiffArtifactStorage] = None
-    item_previous: Optional[BranchDiffArtifactStorage] = None
+    target: ArtifactTarget | None = None
+    item_new: BranchDiffArtifactStorage | None = None
+    item_previous: BranchDiffArtifactStorage | None = None

infrahub/core/diff/model/path.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import asdict, dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import (
     BranchSupportType,
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
     from neo4j.graph import Node as Neo4jNode
     from neo4j.graph import Path as Neo4jPath
     from neo4j.graph import Relationship as Neo4jRelationship
-    from pendulum import Interval
+    from whenever import TimeDelta
 
     from infrahub.graphql.initialization import GraphqlContext
 
@@ -163,6 +163,10 @@ class EnrichedDiffAttribute(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.name)
 
+    @property
+    def num_properties(self) -> int:
+        return len(self.properties)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         return {prop.path_identifier: prop.conflict for prop in self.properties if prop.conflict}
 
@@ -202,6 +206,10 @@ class EnrichedDiffSingleRelationship(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.peer_id)
 
+    @property
+    def num_properties(self) -> int:
+        return len(self.properties)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         if self.conflict:
@@ -248,6 +256,10 @@ class EnrichedDiffRelationship(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.name)
 
+    @property
+    def num_properties(self) -> int:
+        return sum(r.num_properties for r in self.relationships)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         for element in self.relationships:
@@ -308,6 +320,10 @@ class EnrichedDiffNode(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.uuid)
 
+    @property
+    def num_properties(self) -> int:
+        return sum(a.num_properties for a in self.attributes) + sum(r.num_properties for r in self.relationships)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         if self.conflict:
@@ -409,16 +425,16 @@ class EnrichedDiffRootMetadata(BaseSummary):
     from_time: Timestamp
     to_time: Timestamp
     uuid: str
-    partner_uuid: str
     tracking_id: TrackingId
+    partner_uuid: str | None = field(default=None)
     exists_on_database: bool = field(default=False)
 
     def __hash__(self) -> int:
         return hash(self.uuid)
 
     @property
-    def time_range(self) -> Interval:
-        return self.to_time.obj - self.from_time.obj
+    def time_range(self) -> TimeDelta:
+        return self.to_time.get_obj() - self.from_time.get_obj()
 
     def update_metadata(
         self,
@@ -447,8 +463,8 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
         return hash(self.uuid)
 
     @property
-    def time_range(self) -> Interval:
-        return self.to_time.obj - self.from_time.obj
+    def time_range(self) -> TimeDelta:
+        return self.to_time.get_obj() - self.from_time.get_obj()
 
     def get_nodes_without_parents(self) -> set[EnrichedDiffNode]:
         nodes_with_parent_uuids = set()
@@ -470,6 +486,13 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
         except ValueError:
             return False
 
+    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[str, EnrichedDiffNode]:
+        node_map = {}
+        for node in self.nodes:
+            if node_uuids is None or node.uuid in node_uuids:
+                node_map[node.uuid] = node
+        return node_map
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         for node in self.nodes:
@@ -825,13 +848,13 @@ class DatabasePath:
         return "Node" in self.property_node.labels
 
     @property
-    def peer_id(self) -> Optional[str]:
+    def peer_id(self) -> str | None:
         if not self.property_is_peer:
             return None
         return str(self.property_node.get("uuid"))
 
     @property
-    def peer_kind(self) -> Optional[str]:
+    def peer_kind(self) -> str | None:
         if not self.property_is_peer:
             return None
         return str(self.property_node.get("kind"))

infrahub/core/diff/parent_node_adder.py

@@ -0,0 +1,78 @@
+from dataclasses import dataclass, field
+
+from infrahub.core.constants import DiffAction, RelationshipCardinality
+
+from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot
+
+
+@dataclass
+class ParentNodeAddRequest:
+    node_id: str
+    parent_id: str
+    parent_kind: str
+    parent_label: str
+    parent_rel_name: str
+    parent_rel_identifier: str
+    parent_rel_cardinality: RelationshipCardinality
+    parent_rel_label: str = field(default="")
+
+
+class DiffParentNodeAdder:
+    def __init__(self) -> None:
+        self._diff_root: EnrichedDiffRoot | None = None
+        self._node_map: dict[str, EnrichedDiffNode] = {}
+
+    def initialize(self, enriched_diff_root: EnrichedDiffRoot) -> None:
+        self._diff_root = enriched_diff_root
+        self._node_map = enriched_diff_root.get_node_map()
+
+    def get_root(self) -> EnrichedDiffRoot:
+        if not self._diff_root:
+            raise RuntimeError("Must call initialize before using")
+        return self._diff_root
+
+    def get_node(self, node_uuid: str) -> EnrichedDiffNode:
+        return self._node_map[node_uuid]
+
+    def has_node(self, node_uuid: str) -> bool:
+        return node_uuid in self._node_map
+
+    def add_node(self, node: EnrichedDiffNode) -> None:
+        if node.uuid in self._node_map:
+            return
+        self._node_map[node.uuid] = node
+        self.get_root().nodes.add(node)
+
+    def add_parent(self, parent_request: ParentNodeAddRequest) -> EnrichedDiffNode:
+        if not self._diff_root:
+            raise RuntimeError("Must call initialize before using")
+        node = self.get_node(node_uuid=parent_request.node_id)
+        if not self.has_node(node_uuid=parent_request.parent_id):
+            parent = EnrichedDiffNode(
+                uuid=parent_request.parent_id,
+                kind=parent_request.parent_kind,
+                label=parent_request.parent_label,
+                action=DiffAction.UNCHANGED,
+                changed_at=None,
+            )
+            self.add_node(parent)
+        else:
+            parent = self.get_node(node_uuid=parent_request.parent_id)
+
+        try:
+            rel = node.get_relationship(name=parent_request.parent_rel_name)
+            rel.nodes.add(parent)
+        except ValueError:
+            node.relationships.add(
+                EnrichedDiffRelationship(
+                    name=parent_request.parent_rel_name,
+                    identifier=parent_request.parent_rel_identifier,
+                    label=parent_request.parent_rel_label,
+                    cardinality=parent_request.parent_rel_cardinality,
+                    changed_at=None,
+                    action=DiffAction.UNCHANGED,
+                    nodes={parent},
+                )
+            )
+
+        return parent

infrahub/core/diff/payload_builder.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub import config
 from infrahub.core.manager import NodeManager
 from infrahub.core.registry import registry
 from infrahub.exceptions import SchemaNotFoundError
@@ -26,8 +27,18 @@ async def get_display_labels_per_kind(
         if skip_missing_schema:
             return {}
         raise
-    nodes = await NodeManager.get_many(ids=ids, fields=fields, db=db, branch=branch)
-    return {node_id: await node.render_display_label(db=db) for node_id, node in nodes.items()}
+    display_label_map: dict[str, str] = {}
+    offset = 0
+    limit = config.SETTINGS.database.query_size_limit
+    while True:
+        limited_ids = ids[offset : offset + limit]
+        if not limited_ids:
+            break
+        node_map = await NodeManager.get_many(ids=limited_ids, fields=fields, db=db, branch=branch)
+        for node_id, node in node_map.items():
+            display_label_map[node_id] = await node.render_display_label(db=db)
+        offset += limit
+    return display_label_map
 
 
 async def get_display_labels(nodes: dict[str, dict[str, list[str]]], db: InfrahubDatabase) -> dict[str, dict[str, str]]:

infrahub/core/diff/query/filters.py

@@ -16,8 +16,8 @@ class IncExclFilterOptions(BaseModel):
 
 
 class IncExclActionFilterOptions(BaseModel):
-    includes: set[DiffAction] = Field(default_factory=list)
-    excludes: set[DiffAction] = Field(default_factory=list)
+    includes: set[DiffAction] = Field(default_factory=set)
+    excludes: set[DiffAction] = Field(default_factory=set)
 
     @property
     def is_empty(self) -> bool: