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

infrahub/core/diff/query/summary_counts_enricher.py

@@ -0,0 +1,267 @@
+from typing import Any
+
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+from ..model.path import TrackingId
+
+
+class DiffFieldsSummaryCountsEnricherQuery(Query):
+    """Update summary counters for the attributes and relationshipsin in a diff"""
+
+    name = "diff_fields_summary_count_enricher"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+        node_uuids: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        if (diff_id is None and tracking_id is None) or (diff_id and tracking_id):
+            raise ValueError(
+                "DiffFieldsSummaryCountsEnricherQuery requires one and only one of `tracking_id` or `diff_id`"
+            )
+        self.diff_branch_name = diff_branch_name
+        self.tracking_id = tracking_id
+        self.diff_id = diff_id
+        if self.tracking_id is None and self.diff_id is None:
+            raise RuntimeError("tracking_id or diff_id is required")
+        self.node_uuids = node_uuids
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "diff_branch_name": self.diff_branch_name,
+            "diff_id": self.diff_id,
+            "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
+            "node_uuids": self.node_uuids,
+        }
+        query = """
+MATCH (root:DiffRoot)
+WHERE ($diff_id IS NOT NULL AND root.uuid = $diff_id)
+OR ($tracking_id IS NOT NULL AND root.tracking_id = $tracking_id AND root.diff_branch = $diff_branch_name)
+MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode)
+WHERE $node_uuids IS NULL OR dn.uuid IN $node_uuids
+CALL {
+    // ----------------------
+    // handle attribute count updates
+    // ----------------------
+    WITH dn
+    MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty)-[:DIFF_HAS_CONFLICT]->(dc:DiffConflict)
+        WITH da, count(dc) AS num_conflicts
+        SET da.num_conflicts = num_conflicts
+        SET da.contains_conflict = (num_conflicts > 0)
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
+        WITH da, count(dp.action) AS num_added
+        SET da.num_added = num_added
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
+        WITH da, count(dp.action) AS num_updated
+        SET da.num_updated = num_updated
+    }
+    CALL {
+        WITH da
+        OPTIONAL MATCH (da)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
+        WITH da, count(dp.action) AS num_removed
+        SET da.num_removed = num_removed
+    }
+}
+CALL {
+    WITH dn
+    MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
+    CALL {
+        // ----------------------
+        // handle relationship element count updates
+        // ----------------------
+        WITH dr
+        MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement)
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[*..4]->(dc:DiffConflict)
+            WITH dre, count(dc) AS num_conflicts
+            SET dre.num_conflicts = num_conflicts
+            SET dre.contains_conflict = (num_conflicts > 0)
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "added"})
+            WITH dre, count(dp.action) AS num_added
+            SET dre.num_added = num_added
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "updated"})
+            WITH dre, count(dp.action) AS num_updated
+            SET dre.num_updated = num_updated
+        }
+        CALL {
+            WITH dre
+            OPTIONAL MATCH (dre)-[:DIFF_HAS_PROPERTY]->(dp:DiffProperty {action: "removed"})
+            WITH dre, count(dp.action) AS num_removed
+            SET dre.num_removed = num_removed
+        }
+    }
+    // ----------------------
+    // handle relationship count updates
+    // ----------------------
+    OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(conflict_dre:DiffRelationshipElement {contains_conflict: TRUE})
+    WITH dr, sum(conflict_dre.num_conflicts) AS num_conflicts
+    SET dr.num_conflicts = num_conflicts
+    SET dr.contains_conflict = (num_conflicts > 0)
+    WITH dr
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "added"})
+        WITH dr, count(dre.action) AS num_added
+        SET dr.num_added = num_added
+    }
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "updated"})
+        WITH dr, count(dre.action) AS num_updated
+        SET dr.num_updated = num_updated
+    }
+    CALL {
+        WITH dr
+        OPTIONAL MATCH (dr)-[:DIFF_HAS_ELEMENT]->(dre:DiffRelationshipElement {action: "removed"})
+        WITH dr, count(dre.action) AS num_removed
+        SET dr.num_removed = num_removed
+    }
+}
+        """
+        self.add_to_query(query)
+
+
+class DiffNodesSummaryCountsEnricherQuery(Query):
+    """Update summary counters for the nodes and root in a diff"""
+
+    name = "diff_nodes_summary_count_enricher"
+    type = QueryType.WRITE
+    insert_return = False
+
+    def __init__(
+        self,
+        diff_branch_name: str,
+        tracking_id: TrackingId | None = None,
+        diff_id: str | None = None,
+        node_uuids: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        if (diff_id is None and tracking_id is None) or (diff_id and tracking_id):
+            raise ValueError(
+                "DiffNodesSummaryCountsEnricherQuery requires one and only one of `tracking_id` or `diff_id`"
+            )
+        self.diff_branch_name = diff_branch_name
+        self.tracking_id = tracking_id
+        self.diff_id = diff_id
+        if self.tracking_id is None and self.diff_id is None:
+            raise RuntimeError("tracking_id or diff_id is required")
+        self.node_uuids = node_uuids
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params = {
+            "diff_branch_name": self.diff_branch_name,
+            "diff_id": self.diff_id,
+            "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
+            "node_uuids": self.node_uuids,
+        }
+
+        query = """
+MATCH (root:DiffRoot)
+WHERE ($diff_id IS NOT NULL AND root.uuid = $diff_id)
+OR ($tracking_id IS NOT NULL AND root.tracking_id = $tracking_id AND root.diff_branch = $diff_branch_name)
+MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode)
+WHERE $node_uuids IS NULL OR dn.uuid IN $node_uuids
+// ----------------------
+// handle node count updates
+// ----------------------
+WITH root, dn, coalesce(dn.num_conflicts, 0) AS previous_num_conflicts
+CALL {
+    // ----------------------
+    // handle node num_conflicts update
+    // ----------------------
+    WITH dn
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute {contains_conflict: TRUE})
+    RETURN sum(da.num_conflicts) AS num_conflicts
+    UNION ALL
+    WITH dn
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship {contains_conflict: TRUE})
+    RETURN sum(dr.num_conflicts) AS num_conflicts
+    UNION ALL
+    WITH dn
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_CONFLICT]->(dc:DiffConflict)
+    RETURN count(dc) AS num_conflicts
+}
+WITH root, dn, previous_num_conflicts, sum(num_conflicts) AS updated_num_conflicts
+SET dn.num_conflicts = updated_num_conflicts
+SET dn.contains_conflict = (updated_num_conflicts > 0)
+WITH root, dn, updated_num_conflicts - previous_num_conflicts AS num_conflicts_delta
+CALL {
+    // ----------------------
+    // handle node added/updated/removed updates
+    // ----------------------
+    WITH dn
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_ATTRIBUTE]->(da:DiffAttribute)
+    WITH dn, collect(da.action) AS attr_actions
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP]->(dr:DiffRelationship)
+    WITH dn, attr_actions, collect(dr.action) AS rel_actions
+    WITH dn, attr_actions + rel_actions AS actions
+    WITH dn, reduce(counts = [0,0,0], a IN actions |
+        CASE
+            WHEN a = "added" THEN [counts[0] + 1, counts[1], counts[2]]
+            WHEN a = "updated" THEN [counts[0], counts[1] + 1, counts[2]]
+            WHEN a = "removed" THEN [counts[0], counts[1], counts[2] + 1]
+            ELSE counts
+        END
+    ) AS action_counts
+    WITH dn, action_counts[0] AS num_added, action_counts[1] AS num_updated, action_counts[2] AS num_removed
+    SET dn.num_added = num_added
+    SET dn.num_updated = num_updated
+    SET dn.num_removed = num_removed
+}
+// ----------------------
+// handle conflict updates for parent nodes
+// ----------------------
+WITH root, dn, num_conflicts_delta
+CALL {
+    WITH dn, num_conflicts_delta
+    OPTIONAL MATCH (dn)-[:DIFF_HAS_RELATIONSHIP|DIFF_HAS_NODE*1..]->(parent_node:DiffNode)
+    SET parent_node.num_conflicts = parent_node.num_conflicts + num_conflicts_delta
+    SET parent_node.contains_conflict = (parent_node.num_conflicts > 0)
+}
+// ----------------------
+// handle root count updates
+// ----------------------
+WITH root, sum(num_conflicts_delta) AS total_conflicts_delta
+CALL {
+    WITH root, total_conflicts_delta
+    SET root.num_conflicts = coalesce(root.num_conflicts, 0) + total_conflicts_delta
+    SET root.contains_conflict = root.num_conflicts > 0
+    WITH root
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "added"})
+    WITH root, count(dn.action) AS num_added
+    SET root.num_added = num_added
+    WITH root
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "updated"})
+    WITH root, count(dn.action) AS num_updated
+    SET root.num_updated = num_updated
+    WITH root
+    OPTIONAL MATCH (root)-[:DIFF_HAS_NODE]->(dn:DiffNode {action: "removed"})
+    WITH root, count(dn.action) AS num_removed
+    SET root.num_removed = num_removed
+}
+        """
+        self.add_to_query(query)

infrahub/core/diff/query/time_range_query.py

@@ -30,7 +30,7 @@ class EnrichedDiffTimeRangeQuery(Query):
         self.from_time = from_time
         self.to_time = to_time
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "base_branch": self.base_branch_name,
             "diff_branch": self.diff_branch_name,
@@ -41,7 +41,8 @@ class EnrichedDiffTimeRangeQuery(Query):
         query = """
         // get the roots of all diffs in the query
         MATCH (diff_root:DiffRoot)
-        WHERE diff_root.base_branch = $base_branch
+        WHERE (diff_root.is_merged IS NULL OR diff_root.is_merged <> TRUE)
+        AND diff_root.base_branch = $base_branch
         AND diff_root.diff_branch = $diff_branch
         AND diff_root.from_time >= $from_time
         AND diff_root.to_time <= $to_time

infrahub/core/diff/query/update_conflict_query.py

@@ -21,7 +21,7 @@ class EnrichedDiffConflictUpdateQuery(Query):
         self.conflict_id = conflict_id
         self.selection = selection
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"conflict_id": self.conflict_id, "selection": self.selection.value if self.selection else None}
         query = """
         MATCH (conflict:DiffConflict {uuid: $conflict_id})

infrahub/core/diff/query_parser.py

@@ -28,7 +28,6 @@ from .model.path import (
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.query import QueryResult
-    from infrahub.core.schema import MainSchemaTypes
     from infrahub.core.schema.manager import SchemaManager
     from infrahub.core.schema.relationship_schema import RelationshipSchema
 
@@ -397,8 +396,12 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
     force_action: DiffAction | None
     uuid: str
     kind: str
+    db_id: str
+    from_time: Timestamp
+    status: RelationshipStatus
     attributes_by_name: dict[str, DiffAttributeIntermediate] = field(default_factory=dict)
-    relationships_by_name: dict[str, DiffRelationshipIntermediate] = field(default_factory=dict)
+    # {(name, identifier): DiffRelationshipIntermediate}
+    relationships_by_identifier: dict[tuple[str, str], DiffRelationshipIntermediate] = field(default_factory=dict)
 
     def to_diff_node(self, from_time: Timestamp, include_unchanged: bool) -> DiffNode:
         attributes = []
@@ -408,7 +411,7 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
                 attributes.append(diff_attr)
         action, changed_at = self.get_action_and_timestamp(from_time=from_time)
         relationships = []
-        for rel in self.relationships_by_name.values():
+        for rel in self.relationships_by_identifier.values():
             diff_rel = rel.to_diff_relationship(include_unchanged=include_unchanged)
             if include_unchanged or diff_rel.action is not DiffAction.UNCHANGED:
                 relationships.append(diff_rel)
@@ -431,7 +434,7 @@ class DiffNodeIntermediate(TrackedStatusUpdates):
 
     @property
     def is_empty(self) -> bool:
-        return len(self.attributes_by_name) == 0 and len(self.relationships_by_name) == 0
+        return len(self.attributes_by_name) == 0 and len(self.relationships_by_identifier) == 0
 
 
 @dataclass
@@ -495,7 +498,7 @@ class DiffQueryParser:
         for node in diff_root.nodes_by_id.values():
             for attribute_name in node.attributes_by_name:
                 node_field_specifiers_map[node.uuid].add(attribute_name)
-            for relationship_diff in node.relationships_by_name.values():
+            for relationship_diff in node.relationships_by_identifier.values():
                 node_field_specifiers_map[node.uuid].add(relationship_diff.identifier)
         return node_field_specifiers_map
 
@@ -567,35 +570,53 @@ class DiffQueryParser:
             diff_root.nodes_by_id[node_id] = DiffNodeIntermediate(
                 uuid=node_id,
                 kind=database_path.node_kind,
+                db_id=database_path.node_db_id,
+                from_time=database_path.node_changed_at,
+                status=database_path.node_status,
                 force_action=DiffAction.UPDATED
                 if database_path.node_branch_support is BranchSupportType.AGNOSTIC
                 else None,
             )
         diff_node = diff_root.nodes_by_id[node_id]
+        # special handling for nodes that have their kind updated, which results in 2 nodes with the same uuid
+        if diff_node.db_id != database_path.node_db_id and (
+            database_path.node_changed_at > diff_node.from_time
+            or (
+                database_path.node_changed_at >= diff_node.from_time
+                and (diff_node.status, database_path.node_status)
+                == (RelationshipStatus.DELETED, RelationshipStatus.ACTIVE)
+            )
+        ):
+            diff_node.kind = database_path.node_kind
+            diff_node.db_id = database_path.node_db_id
+            diff_node.from_time = database_path.node_changed_at
+            diff_node.status = database_path.node_status
         diff_node.track_database_path(database_path=database_path)
         return diff_node
 
-    def _get_relationship_schema(
-        self, database_path: DatabasePath, node_schema: MainSchemaTypes
-    ) -> RelationshipSchema | None:
-        relationship_schemas = node_schema.get_relationships_by_identifier(id=database_path.attribute_name)
-        if len(relationship_schemas) == 1:
-            return relationship_schemas[0]
-        possible_path_directions = database_path.possible_relationship_directions
-        for rel_schema in relationship_schemas:
-            if rel_schema.direction in possible_path_directions:
-                return rel_schema
+    def _get_relationship_schema(self, database_path: DatabasePath) -> RelationshipSchema | None:
+        branches_to_check = [database_path.deepest_branch]
+        if database_path.deepest_branch == self.diff_branch_name:
+            branches_to_check.append(self.base_branch_name)
+        for schema_branch_name in branches_to_check:
+            node_schema = self.schema_manager.get(
+                name=database_path.node_kind, branch=schema_branch_name, duplicate=False
+            )
+            relationship_schemas = node_schema.get_relationships_by_identifier(id=database_path.attribute_name)
+            if len(relationship_schemas) == 1:
+                return relationship_schemas[0]
+            possible_path_directions = database_path.possible_relationship_directions
+            for rel_schema in relationship_schemas:
+                if rel_schema.direction in possible_path_directions:
+                    return rel_schema
         return None
 
     def _update_attribute_level(self, database_path: DatabasePath, diff_node: DiffNodeIntermediate) -> None:
-        node_schema = self.schema_manager.get(
-            name=database_path.node_kind, branch=database_path.deepest_branch, duplicate=False
-        )
         if "Attribute" in database_path.attribute_node.labels:
             diff_attribute = self._get_diff_attribute(database_path=database_path, diff_node=diff_node)
             self._update_attribute_property(database_path=database_path, diff_attribute=diff_attribute)
             return
-        relationship_schema = self._get_relationship_schema(database_path=database_path, node_schema=node_schema)
+        relationship_schema = self._get_relationship_schema(database_path=database_path)
         if not relationship_schema:
             return
         diff_relationship = self._get_diff_relationship(
@@ -649,7 +670,9 @@ class DiffQueryParser:
         relationship_schema: RelationshipSchema,
         database_path: DatabasePath,
     ) -> DiffRelationshipIntermediate:
-        diff_relationship = diff_node.relationships_by_name.get(relationship_schema.name)
+        diff_relationship = diff_node.relationships_by_identifier.get(
+            (relationship_schema.name, relationship_schema.get_identifier())
+        )
         if not diff_relationship:
             branch_name = database_path.deepest_branch
             from_time = self.from_time
@@ -663,7 +686,9 @@ class DiffQueryParser:
                 identifier=relationship_schema.get_identifier(),
                 from_time=from_time,
             )
-            diff_node.relationships_by_name[relationship_schema.name] = diff_relationship
+            diff_node.relationships_by_identifier[relationship_schema.name, relationship_schema.get_identifier()] = (
+                diff_relationship
+            )
         return diff_relationship
 
     def _apply_base_branch_previous_values(self) -> None:
@@ -700,8 +725,8 @@ class DiffQueryParser:
     def _apply_relationship_previous_values(
         self, diff_node: DiffNodeIntermediate, base_diff_node: DiffNodeIntermediate
     ) -> None:
-        for relationship_name, diff_relationship in diff_node.relationships_by_name.items():
-            base_diff_relationship = base_diff_node.relationships_by_name.get(relationship_name)
+        for relationship_key, diff_relationship in diff_node.relationships_by_identifier.items():
+            base_diff_relationship = base_diff_node.relationships_by_identifier.get(relationship_key)
             if not base_diff_relationship:
                 continue
             for db_id, property_set in diff_relationship.properties_by_db_id.items():
@@ -754,7 +779,7 @@ class DiffQueryParser:
                         continue
                     if ordered_diff_values[-1].changed_at >= self.diff_branched_from_time:
                         return
-            for relationship_diff in node_diff.relationships_by_name.values():
+            for relationship_diff in node_diff.relationships_by_identifier.values():
                 for diff_relationship_property_list in relationship_diff.properties_by_db_id.values():
                     for diff_relationship_property in diff_relationship_property_list:
                         if diff_relationship_property.changed_at >= self.diff_branched_from_time:

infrahub/core/diff/repository/deserializer.py

@@ -18,10 +18,12 @@ from ..model.path import (
     EnrichedDiffSingleRelationship,
     deserialize_tracking_id,
 )
+from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 
 
 class EnrichedDiffDeserializer:
-    def __init__(self) -> None:
+    def __init__(self, parent_adder: DiffParentNodeAdder) -> None:
+        self.parent_adder = parent_adder
         self._diff_root_map: dict[str, EnrichedDiffRoot] = {}
         self._diff_node_map: dict[tuple[str, str], EnrichedDiffNode] = {}
         self._diff_node_attr_map: dict[tuple[str, str, str], EnrichedDiffAttribute] = {}
@@ -127,14 +129,15 @@ class EnrichedDiffDeserializer:
 
     def _deserialize_parents(self) -> None:
         for enriched_root, node_path_tuples in self._parents_path_map.items():
+            self.parent_adder.initialize(enriched_diff_root=enriched_root)
             for node_uuid, parents_path in node_path_tuples:
                 # Remove the node itself from the path
                 parents_path_slice = parents_path.nodes[1:]
 
                 # TODO Ensure the list is even
                 current_node_uuid = node_uuid
-                for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2]):
-                    enriched_root.add_parent(
+                for rel, parent in zip(parents_path_slice[::2], parents_path_slice[1::2], strict=False):
+                    parent_request = ParentNodeAddRequest(
                         node_id=current_node_uuid,
                         parent_id=parent.get("uuid"),
                         parent_kind=parent.get("kind"),
@@ -144,6 +147,7 @@ class EnrichedDiffDeserializer:
                         parent_rel_cardinality=RelationshipCardinality(rel.get("cardinality")),
                         parent_rel_label=rel.get("label"),
                     )
+                    self.parent_adder.add_parent(parent_request=parent_request)
                     current_node_uuid = parent.get("uuid")
 
     @classmethod
@@ -164,23 +168,23 @@ class EnrichedDiffDeserializer:
     def build_diff_root_metadata(cls, root_node: Neo4jNode) -> EnrichedDiffRootMetadata:
         from_time = Timestamp(str(root_node.get("from_time")))
         to_time = Timestamp(str(root_node.get("to_time")))
-        tracking_id_str = cls._get_str_or_none_property_value(node=root_node, property_name="tracking_id")
-        tracking_id = None
-        if tracking_id_str:
-            tracking_id = deserialize_tracking_id(tracking_id_str=tracking_id_str)
+        partner_uuid = cls._get_str_or_none_property_value(node=root_node, property_name="partner_uuid")
+        tracking_id_str = str(root_node.get("tracking_id"))
+        tracking_id = deserialize_tracking_id(tracking_id_str=tracking_id_str)
         return EnrichedDiffRootMetadata(
             base_branch_name=str(root_node.get("base_branch")),
             diff_branch_name=str(root_node.get("diff_branch")),
             from_time=from_time,
             to_time=to_time,
             uuid=str(root_node.get("uuid")),
-            partner_uuid=str(root_node.get("partner_uuid")),
+            partner_uuid=partner_uuid,
             tracking_id=tracking_id,
-            num_added=int(root_node.get("num_added")),
-            num_updated=int(root_node.get("num_updated")),
-            num_removed=int(root_node.get("num_removed")),
-            num_conflicts=int(root_node.get("num_conflicts")),
+            num_added=int(root_node.get("num_added", 0)),
+            num_updated=int(root_node.get("num_updated", 0)),
+            num_removed=int(root_node.get("num_removed", 0)),
+            num_conflicts=int(root_node.get("num_conflicts", 0)),
             contains_conflict=str(root_node.get("contains_conflict")).lower() == "true",
+            exists_on_database=True,
         )
 
     def _deserialize_diff_node(self, node_node: Neo4jNode, enriched_root: EnrichedDiffRoot) -> EnrichedDiffNode:
@@ -197,10 +201,10 @@ class EnrichedDiffDeserializer:
             changed_at=Timestamp(timestamp_str) if timestamp_str else None,
             action=DiffAction(str(node_node.get("action"))),
             path_identifier=str(node_node.get("path_identifier")),
-            num_added=int(node_node.get("num_added")),
-            num_updated=int(node_node.get("num_updated")),
-            num_removed=int(node_node.get("num_removed")),
-            num_conflicts=int(node_node.get("num_conflicts")),
+            num_added=int(node_node.get("num_added", 0)),
+            num_updated=int(node_node.get("num_updated", 0)),
+            num_removed=int(node_node.get("num_removed", 0)),
+            num_conflicts=int(node_node.get("num_conflicts", 0)),
             contains_conflict=str(node_node.get("contains_conflict")).lower() == "true",
         )
         self._diff_node_map[node_key] = enriched_node
@@ -220,10 +224,10 @@ class EnrichedDiffDeserializer:
             changed_at=Timestamp(str(diff_attr_node.get("changed_at"))),
             path_identifier=str(diff_attr_node.get("path_identifier")),
             action=DiffAction(str(diff_attr_node.get("action"))),
-            num_added=int(diff_attr_node.get("num_added")),
-            num_updated=int(diff_attr_node.get("num_updated")),
-            num_removed=int(diff_attr_node.get("num_removed")),
-            num_conflicts=int(diff_attr_node.get("num_conflicts")),
+            num_added=int(diff_attr_node.get("num_added", 0)),
+            num_updated=int(diff_attr_node.get("num_updated", 0)),
+            num_removed=int(diff_attr_node.get("num_removed", 0)),
+            num_conflicts=int(diff_attr_node.get("num_conflicts", 0)),
             contains_conflict=str(diff_attr_node.get("contains_conflict")).lower() == "true",
         )
         self._diff_node_attr_map[attr_key] = enriched_attr
@@ -247,10 +251,10 @@ class EnrichedDiffDeserializer:
             changed_at=Timestamp(timestamp_str) if timestamp_str else None,
             action=DiffAction(str(relationship_group_node.get("action"))),
             path_identifier=str(relationship_group_node.get("path_identifier")),
-            num_added=int(relationship_group_node.get("num_added")),
-            num_conflicts=int(relationship_group_node.get("num_conflicts")),
-            num_removed=int(relationship_group_node.get("num_removed")),
-            num_updated=int(relationship_group_node.get("num_updated")),
+            num_added=int(relationship_group_node.get("num_added", 0)),
+            num_conflicts=int(relationship_group_node.get("num_conflicts", 0)),
+            num_removed=int(relationship_group_node.get("num_removed", 0)),
+            num_updated=int(relationship_group_node.get("num_updated", 0)),
             contains_conflict=str(relationship_group_node.get("contains_conflict")).lower() == "true",
         )
 
@@ -282,10 +286,10 @@ class EnrichedDiffDeserializer:
             peer_id=diff_element_peer_id,
             peer_label=peer_label,
             path_identifier=str(relationship_element_node.get("path_identifier")),
-            num_added=int(relationship_element_node.get("num_added")),
-            num_updated=int(relationship_element_node.get("num_updated")),
-            num_removed=int(relationship_element_node.get("num_removed")),
-            num_conflicts=int(relationship_element_node.get("num_conflicts")),
+            num_added=int(relationship_element_node.get("num_added", 0)),
+            num_updated=int(relationship_element_node.get("num_updated", 0)),
+            num_removed=int(relationship_element_node.get("num_removed", 0)),
+            num_conflicts=int(relationship_element_node.get("num_conflicts", 0)),
             contains_conflict=str(relationship_element_node.get("contains_conflict")).lower() == "true",
         )
         enriched_relationship_group.relationships.add(enriched_rel_element)