infrahub-server 1.2.9rc0__py3-none-any.whl → 1.2.10__py3-none-any.whl

infrahub/core/diff/model/path.py

@@ -81,6 +81,21 @@ def deserialize_tracking_id(tracking_id_str: str) -> TrackingId:
     raise ValueError(f"{tracking_id_str} is not a valid TrackingId")
 
 
+@dataclass
+class NodeIdentifier:
+    """Uniquely identifying nodes that have had their kind or inheritance updated requires all of these fields"""
+
+    uuid: str
+    kind: str
+    db_id: str
+
+    def __hash__(self) -> int:
+        return hash(f"{self.uuid}:{self.kind}:{self.db_id}")
+
+    def __str__(self) -> str:
+        return f"{self.kind} '{self.uuid}' ({self.db_id})"
+
+
 @dataclass
 class NodeDiffFieldSummary:
     kind: str
@@ -307,18 +322,26 @@ class ParentNodeInfo:
 
 @dataclass
 class EnrichedDiffNode(BaseSummary):
-    uuid: str
-    kind: str
+    identifier: NodeIdentifier
     label: str
     path_identifier: str = field(default="", kw_only=True)
     changed_at: Timestamp | None = field(default=None, kw_only=True)
     action: DiffAction
+    is_node_kind_migration: bool = field(default=False)
     conflict: EnrichedDiffConflict | None = field(default=None)
     attributes: set[EnrichedDiffAttribute] = field(default_factory=set)
     relationships: set[EnrichedDiffRelationship] = field(default_factory=set)
 
     def __hash__(self) -> int:
-        return hash(self.uuid)
+        return hash(self.identifier)
+
+    @property
+    def uuid(self) -> str:
+        return self.identifier.uuid
+
+    @property
+    def kind(self) -> str:
+        return self.identifier.kind
 
     @property
     def num_properties(self) -> int:
@@ -402,11 +425,11 @@ class EnrichedDiffNode(BaseSummary):
     @classmethod
     def from_calculated_node(cls, calculated_node: DiffNode) -> EnrichedDiffNode:
         return EnrichedDiffNode(
-            uuid=calculated_node.uuid,
-            kind=calculated_node.kind,
+            identifier=calculated_node.identifier,
             label="",
             changed_at=calculated_node.changed_at,
             action=calculated_node.action,
+            is_node_kind_migration=calculated_node.is_node_kind_migration,
             attributes={
                 EnrichedDiffAttribute.from_calculated_attribute(calculated_attribute=attr)
                 for attr in calculated_node.attributes
@@ -473,24 +496,24 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
                 nodes_with_parent_uuids |= {child_n.uuid for child_n in r.nodes}
         return {node for node in self.nodes if node.uuid not in nodes_with_parent_uuids}
 
-    def get_node(self, node_uuid: str) -> EnrichedDiffNode:
+    def get_node(self, node_identifier: NodeIdentifier) -> EnrichedDiffNode:
         for n in self.nodes:
-            if n.uuid == node_uuid:
+            if n.identifier == node_identifier:
                 return n
-        raise ValueError(f"No node {node_uuid} in diff root")
+        raise ValueError(f"No node {node_identifier} in diff root")
 
-    def has_node(self, node_uuid: str) -> bool:
+    def has_node(self, node_identifier: NodeIdentifier) -> bool:
         try:
-            self.get_node(node_uuid=node_uuid)
+            self.get_node(node_identifier=node_identifier)
             return True
         except ValueError:
             return False
 
-    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[str, EnrichedDiffNode]:
+    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[NodeIdentifier, EnrichedDiffNode]:
         node_map = {}
         for node in self.nodes:
-            if node_uuids is None or node.uuid in node_uuids:
-                node_map[node.uuid] = node
+            if node_uuids is None or node.identifier.uuid in node_uuids:
+                node_map[node.identifier] = node
         return node_map
 
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
@@ -522,49 +545,6 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
             nodes={EnrichedDiffNode.from_calculated_node(calculated_node=n) for n in calculated_diff.nodes},
         )
 
-    def add_parent(
-        self,
-        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 = "",
-    ) -> EnrichedDiffNode:
-        node = self.get_node(node_uuid=node_id)
-        if not self.has_node(node_uuid=parent_id):
-            parent = EnrichedDiffNode(
-                uuid=parent_id,
-                kind=parent_kind,
-                label=parent_label,
-                action=DiffAction.UNCHANGED,
-                changed_at=None,
-            )
-            self.nodes.add(parent)
-
-        else:
-            parent = self.get_node(node_uuid=parent_id)
-
-        if node.has_relationship(name=parent_rel_name):
-            rel = node.get_relationship(name=parent_rel_name)
-            rel.nodes.add(parent)
-        else:
-            node.relationships.add(
-                EnrichedDiffRelationship(
-                    name=parent_rel_name,
-                    identifier=parent_rel_identifier,
-                    label=parent_rel_label,
-                    cardinality=parent_rel_cardinality,
-                    changed_at=None,
-                    action=DiffAction.UNCHANGED,
-                    nodes={parent},
-                )
-            )
-
-        return parent
-
 
 @dataclass
 class EnrichedDiffsMetadata:
@@ -650,6 +630,14 @@ class EnrichedDiffs(EnrichedDiffsMetadata):
     def branch_node_uuids(self) -> set[str]:
         return {n.uuid for n in self.diff_branch_diff.nodes}
 
+    @property
+    def base_node_identifiers(self) -> set[NodeIdentifier]:
+        return {n.identifier for n in self.base_branch_diff.nodes}
+
+    @property
+    def branch_node_identifiers(self) -> set[NodeIdentifier]:
+        return {n.identifier for n in self.diff_branch_diff.nodes}
+
 
 @dataclass
 class CalculatedDiffs:
@@ -697,13 +685,21 @@ class DiffRelationship:
 
 @dataclass
 class DiffNode:
-    uuid: str
-    kind: str
+    identifier: NodeIdentifier
     changed_at: Timestamp
     action: DiffAction
+    is_node_kind_migration: bool = field(default=False)
     attributes: list[DiffAttribute] = field(default_factory=list)
     relationships: list[DiffRelationship] = field(default_factory=list)
 
+    @property
+    def uuid(self) -> str:
+        return self.identifier.uuid
+
+    @property
+    def kind(self) -> str:
+        return self.identifier.kind
+
 
 @dataclass
 class DiffRoot:
@@ -780,6 +776,10 @@ class DatabasePath:
     def node_db_id(self) -> str:
         return self.node_node.element_id
 
+    @property
+    def node_labels(self) -> frozenset[str]:
+        return self.node_node.labels
+
     @property
     def node_kind(self) -> str:
         return str(self.node_node.get("kind"))

infrahub/core/diff/parent_node_adder.py

@@ -2,14 +2,13 @@ from dataclasses import dataclass, field
 
 from infrahub.core.constants import DiffAction, RelationshipCardinality
 
-from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot
+from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot, NodeIdentifier
 
 
 @dataclass
 class ParentNodeAddRequest:
-    node_id: str
-    parent_id: str
-    parent_kind: str
+    node_identifier: NodeIdentifier
+    parent_identifier: NodeIdentifier
     parent_label: str
     parent_rel_name: str
     parent_rel_identifier: str
@@ -20,7 +19,7 @@ class ParentNodeAddRequest:
 class DiffParentNodeAdder:
     def __init__(self) -> None:
         self._diff_root: EnrichedDiffRoot | None = None
-        self._node_map: dict[str, EnrichedDiffNode] = {}
+        self._node_map: dict[NodeIdentifier, EnrichedDiffNode] = {}
 
     def initialize(self, enriched_diff_root: EnrichedDiffRoot) -> None:
         self._diff_root = enriched_diff_root
@@ -31,33 +30,32 @@ class DiffParentNodeAdder:
             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 get_node(self, identifier: NodeIdentifier) -> EnrichedDiffNode:
+        return self._node_map[identifier]
 
-    def has_node(self, node_uuid: str) -> bool:
-        return node_uuid in self._node_map
+    def has_node(self, identifier: NodeIdentifier) -> bool:
+        return identifier in self._node_map
 
     def add_node(self, node: EnrichedDiffNode) -> None:
-        if node.uuid in self._node_map:
+        if node.identifier in self._node_map:
             return
-        self._node_map[node.uuid] = node
+        self._node_map[node.identifier] = 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):
+        node = self.get_node(identifier=parent_request.node_identifier)
+        if not self.has_node(identifier=parent_request.parent_identifier):
             parent = EnrichedDiffNode(
-                uuid=parent_request.parent_id,
-                kind=parent_request.parent_kind,
+                identifier=parent_request.parent_identifier,
                 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)
+            parent = self.get_node(identifier=parent_request.parent_identifier)
 
         try:
             rel = node.get_relationship(name=parent_request.parent_rel_name)

infrahub/core/diff/query/drop_nodes.py

@@ -0,0 +1,42 @@
+from typing import Any
+
+from infrahub.core.diff.model.path import NodeIdentifier
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+
+class EnrichedDiffDropNodesQuery(Query):
+    name = "enriched_diff_drop_nodes"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(self, enriched_diff_uuid: str, node_identifiers: list[NodeIdentifier], **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.enriched_diff_uuid = enriched_diff_uuid
+        self.node_identifiers = node_identifiers
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "diff_root_uuid": self.enriched_diff_uuid,
+            "node_uuids": [ni.uuid for ni in self.node_identifiers],
+            "node_identifiers_map": {ni.uuid: ni.kind for ni in self.node_identifiers},
+        }
+        query = """
+        MATCH (d_root:DiffRoot {uuid: $diff_root_uuid})
+        MATCH (d_root)-[:DIFF_HAS_NODE]->(dn:DiffNode)
+        WHERE dn.uuid IN $node_uuids
+        AND dn.kind IN $node_identifiers_map[dn.uuid]
+        OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]-(da:DiffAttribute)
+        OPTIONAL MATCH (da)-[*]->(diff_thing)
+        DETACH DELETE diff_thing
+        DETACH DELETE da
+        WITH dn
+        OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement)
+        OPTIONAL MATCH (dre)-[*]->(diff_thing)
+        DETACH DELETE diff_thing
+        DETACH DELETE dre
+        DETACH DELETE dr
+        DETACH DELETE dn
+        """
+        self.add_to_query(query=query)

infrahub/core/diff/query/field_specifiers.py

@@ -18,20 +18,21 @@ class EnrichedDiffFieldSpecifiersQuery(Query):
 CALL {
     MATCH (root:DiffRoot {uuid: $diff_id})-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_ATTRIBUTE]->(attr:DiffAttribute)
     WHERE (root.is_merged IS NULL OR root.is_merged <> TRUE)
-    RETURN node.uuid AS node_uuid, attr.name AS field_name
+    RETURN node.uuid AS node_uuid, node.kind AS node_kind, attr.name AS field_name
     UNION
     MATCH (root:DiffRoot {uuid: $diff_id})-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_RELATIONSHIP]->(rel:DiffRelationship)
     WHERE (root.is_merged IS NULL OR root.is_merged <> TRUE)
-    RETURN node.uuid AS node_uuid, rel.identifier AS field_name
+    RETURN node.uuid AS node_uuid, node.kind AS node_kind, rel.identifier AS field_name
 }
         """
         self.add_to_query(query=query)
-        self.return_labels = ["node_uuid", "field_name"]
-        self.order_by = ["node_uuid", "field_name"]
+        self.return_labels = ["node_uuid", "node_kind", "field_name"]
+        self.order_by = ["node_uuid", "node_kind", "field_name"]
 
-    def get_node_field_specifier_tuples(self) -> Generator[tuple[str, str], None, None]:
+    def get_node_field_specifier_tuples(self) -> Generator[tuple[str, str, str], None, None]:
         for result in self.get_results():
             node_uuid = result.get_as_str("node_uuid")
+            node_kind = result.get_as_str("node_kind")
             field_name = result.get_as_str("field_name")
-            if node_uuid and field_name:
-                yield (node_uuid, field_name)
+            if node_uuid and node_kind and field_name:
+                yield (node_uuid, node_kind, field_name)

infrahub/core/diff/query/filters.py

@@ -1,6 +1,10 @@
+from collections import defaultdict
+from typing import Any
+
 from pydantic import BaseModel, Field
 
 from infrahub.core.constants import DiffAction
+from infrahub.core.diff.model.path import NodeIdentifier
 from infrahub.core.query.utils import filter_and, filter_or
 
 
@@ -29,6 +33,7 @@ class IncExclActionFilterOptions(BaseModel):
 class EnrichedDiffQueryFilters(BaseModel):
     ids: list[str] = Field(default_factory=list)
     kind: IncExclFilterOptions = IncExclFilterOptions()
+    identifiers: list[NodeIdentifier] = Field(default_factory=list)
     namespace: IncExclFilterOptions = IncExclFilterOptions()
     status: IncExclActionFilterOptions = IncExclActionFilterOptions()
     only_conflicted: bool = Field(default=False)
@@ -37,6 +42,7 @@ class EnrichedDiffQueryFilters(BaseModel):
     def is_empty(self) -> bool:
         if (
             not self.ids
+            and not self.identifiers
             and self.only_conflicted is False
             and self.kind.is_empty
             and self.namespace.is_empty
@@ -48,12 +54,20 @@ class EnrichedDiffQueryFilters(BaseModel):
     def generate(self) -> tuple[str, dict]:
         default_filter = ""
 
-        params = {}
+        params: dict[str, Any] = {}
 
         if self.ids:
             params["ids"] = self.ids
             return "diff_node.uuid in $ids", params
 
+        if self.identifiers:
+            params["ids"] = [n.uuid for n in self.identifiers]
+            id_kind_map: dict[str, list[str]] = defaultdict(list)
+            for node_identifier in self.identifiers:
+                id_kind_map[node_identifier.uuid].append(node_identifier.kind)
+            params["id_kind_map"] = id_kind_map
+            return "diff_node.uuid in $ids AND diff_node.kind IN $id_kind_map[diff_node.uuid]", params
+
         filters_list = []
 
         if self.is_empty: