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

infrahub/core/changelog/models.py

@@ -0,0 +1,488 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Self, cast
+from uuid import UUID
+
+from pydantic import BaseModel, Field, PrivateAttr, computed_field, field_validator, model_validator
+
+from infrahub.core.constants import NULL_VALUE, DiffAction, RelationshipCardinality, RelationshipKind
+
+if TYPE_CHECKING:
+    from infrahub.core.attribute import BaseAttribute
+    from infrahub.core.branch import Branch
+    from infrahub.core.manager import RelationshipSchema
+    from infrahub.core.query.relationship import RelationshipPeerData
+    from infrahub.core.relationship.model import Relationship
+    from infrahub.database import InfrahubDatabase
+
+
+class PropertyChangelog(BaseModel):
+    name: str = Field(..., description="The name of the property")
+    value: str | bool | None = Field(..., description="The updated or current value of the property")
+    value_previous: str | bool | None = Field(
+        ...,
+        description="The previous value of the property, a `null` value indicates that the property didn't previously have a value",
+    )
+
+    @computed_field
+    def value_type(self) -> str:
+        """The value_type of the property, used to help external systems"""
+        if isinstance(self.value, str):
+            return "Text"
+
+        return "Boolean"
+
+    @computed_field
+    def value_update_status(self) -> DiffAction:
+        """Indicate how the value was changed during this update"""
+        if self.value == self.value_previous:
+            return DiffAction.UNCHANGED
+        if self.value_previous is not None and self.value is None:
+            return DiffAction.REMOVED
+        if self.value_previous is None and self.value is not None:
+            return DiffAction.ADDED
+
+        return DiffAction.UPDATED
+
+
+class AttributeChangelog(BaseModel):
+    name: str = Field(..., description="The name of the attribute")
+    value: Any = Field(default=None, description="The current value of the attribute")
+    value_previous: Any = Field(default=None, description="The previous value of the attribute")
+    properties: dict[str, PropertyChangelog] = Field(
+        default_factory=dict, description="The properties that were updated during this update"
+    )
+    kind: str = Field(..., description="The attribute kind")
+
+    @computed_field
+    def value_update_status(self) -> DiffAction:
+        """Indicate how the peer was changed during this update"""
+        if self.value == self.value_previous:
+            return DiffAction.UNCHANGED
+        if self.value_previous is not None and self.value is None:
+            return DiffAction.REMOVED
+        if self.value_previous is None and self.value is not None:
+            return DiffAction.ADDED
+
+        return DiffAction.UPDATED
+
+    def add_property(self, name: str, value_current: bool | str | None, value_previous: bool | str | None) -> None:
+        self.properties[name] = PropertyChangelog(name=name, value=value_current, value_previous=value_previous)
+
+    @property
+    def has_updates(self) -> bool:
+        if self.value_update_status != DiffAction.UNCHANGED or self.properties:
+            return True
+        return False
+
+    @field_validator("value", "value_previous")
+    @classmethod
+    def convert_null_values(cls, value: Any) -> Any:
+        if isinstance(value, str) and value == NULL_VALUE:
+            return None
+        return value
+
+    @model_validator(mode="after")
+    def filter_sensitive(self) -> Self:
+        if self.kind in ["HashedPassword", "Password"]:
+            if self.value is not None:
+                self.value = "***"
+            if self.value_previous is not None:
+                self.value_previous = "***"
+
+        return self
+
+
+class RelationshipCardinalityOneChangelog(BaseModel):
+    name: str = Field(..., description="The name of the relationship")
+    peer_id_previous: str | None = Field(default=None, description="The previous peer of this relationship")
+    peer_kind_previous: str | None = Field(default=None, description="The node kind of the previous peer")
+    peer_id: str | None = Field(default=None, description="The current peer of this relationship")
+    peer_kind: str | None = Field(default=None, description="The node kind of the current peer")
+    properties: dict[str, PropertyChangelog] = Field(
+        default_factory=dict, description="Changes to properties of this relationship if any were made"
+    )
+    _parent: ChangelogRelatedNode | None = PrivateAttr(default=None)
+
+    @property
+    def parent(self) -> ChangelogRelatedNode | None:
+        return self._parent
+
+    @computed_field
+    def cardinality(self) -> str:
+        return "one"
+
+    @computed_field
+    def peer_status(self) -> DiffAction:
+        """Indicate how the peer was changed during this update"""
+        if self.peer_id_previous == self.peer_id:
+            return DiffAction.UNCHANGED
+        if self.peer_id_previous and not self.peer_id:
+            return DiffAction.REMOVED
+        if self.peer_id and not self.peer_id_previous:
+            return DiffAction.ADDED
+        return DiffAction.UPDATED
+
+    def add_property(self, name: str, value_current: bool | str | None, value_previous: bool | str | None) -> None:
+        self.properties[name] = PropertyChangelog(name=name, value=value_current, value_previous=value_previous)
+
+    def set_parent(self, parent_id: str, parent_kind: str) -> None:
+        self._parent = ChangelogRelatedNode(node_id=parent_id, node_kind=parent_kind)
+
+    def set_parent_from_relationship(self, relationship: Relationship) -> None:
+        if relationship.schema.kind == RelationshipKind.PARENT:
+            if (
+                self.peer_status in [DiffAction.ADDED, DiffAction.UNCHANGED, DiffAction.UPDATED]
+                and self.peer_id
+                and self.peer_kind
+            ):
+                self._parent = ChangelogRelatedNode(node_id=self.peer_id, node_kind=self.peer_kind)
+            elif self.peer_id_previous and self.peer_kind_previous:
+                self._parent = ChangelogRelatedNode(node_id=self.peer_id_previous, node_kind=self.peer_kind_previous)
+
+    @property
+    def is_empty(self) -> bool:
+        return self.peer_status == DiffAction.UNCHANGED and not self.properties
+
+
+class RelationshipPeerChangelog(BaseModel):
+    peer_id: str = Field(..., description="The ID of the peer")
+    peer_kind: str = Field(..., description="The node kind of the peer")
+    peer_status: DiffAction = Field(
+        ..., description="Indicate how the relationship to this peer was changed in this update"
+    )
+    properties: dict[str, PropertyChangelog] = Field(
+        default_factory=dict, description="Changes to properties of this relationship if any were made"
+    )
+
+    def add_property(self, name: str, value_current: bool | str | None, value_previous: bool | str | None) -> None:
+        self.properties[name] = PropertyChangelog(name=name, value=value_current, value_previous=value_previous)
+
+
+class RelationshipCardinalityManyChangelog(BaseModel):
+    name: str
+    peers: list[RelationshipPeerChangelog] = Field(default_factory=list)
+
+    @computed_field
+    def cardinality(self) -> str:
+        return "many"
+
+    def add_new_peer(self, relationship: Relationship) -> None:
+        properties: dict[str, PropertyChangelog] = {}
+        properties["is_protected"] = PropertyChangelog(
+            name="is_protected", value=relationship.is_protected, value_previous=None
+        )
+        properties["is_visible"] = PropertyChangelog(
+            name="is_visible", value=relationship.is_protected, value_previous=None
+        )
+        if owner := getattr(relationship, "owner_id", None):
+            properties["owner"] = PropertyChangelog(name="owner", value=owner, value_previous=None)
+        if source := getattr(relationship, "source_id", None):
+            properties["source"] = PropertyChangelog(name="source_id", value=source, value_previous=None)
+
+        self.peers.append(
+            RelationshipPeerChangelog(
+                peer_id=relationship.get_peer_id(),
+                peer_kind=relationship.get_peer_kind(),
+                peer_status=DiffAction.ADDED,
+                properties=properties,
+            )
+        )
+
+    def remove_peer(self, peer_id: str, peer_kind: str) -> None:
+        self.peers.append(
+            RelationshipPeerChangelog(
+                peer_id=peer_id,
+                peer_kind=peer_kind,
+                peer_status=DiffAction.REMOVED,
+            )
+        )
+
+    @property
+    def is_empty(self) -> bool:
+        return not self.peers
+
+
+class ChangelogRelatedNode(BaseModel):
+    node_id: str
+    node_kind: str
+
+
+class NodeChangelog(BaseModel):
+    """Emitted when a node is updated"""
+
+    node_id: str
+    node_kind: str
+    display_label: str
+
+    attributes: dict[str, AttributeChangelog] = Field(default_factory=dict)
+    relationships: dict[str, RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog] = Field(
+        default_factory=dict
+    )
+
+    _parent: ChangelogRelatedNode | None = PrivateAttr(default=None)
+
+    @property
+    def parent(self) -> ChangelogRelatedNode | None:
+        return self._parent
+
+    @property
+    def updated_fields(self) -> list[str]:
+        """Return a list of update fields i.e. attributes and relationships"""
+        return list(self.relationships.keys()) + list(self.attributes.keys())
+
+    @property
+    def has_changes(self) -> bool:
+        return len(self.updated_fields) > 0
+
+    @property
+    def root_node_id(self) -> str:
+        """Return the top level node_id"""
+        if self.parent:
+            return self.parent.node_id
+        return self.node_id
+
+    def add_parent(self, parent: ChangelogRelatedNode) -> None:
+        self._parent = parent
+
+    def add_parent_from_relationship(self, parent: Relationship) -> None:
+        self._parent = ChangelogRelatedNode(node_id=parent.get_peer_id(), node_kind=parent.get_peer_kind())
+
+    def create_relationship(self, relationship: Relationship) -> None:
+        if relationship.schema.cardinality == RelationshipCardinality.ONE:
+            peer_id = relationship.get_peer_id()
+            peer_kind = relationship.get_peer_kind()
+            if relationship.schema.kind == RelationshipKind.PARENT:
+                self._parent = ChangelogRelatedNode(node_id=peer_id, node_kind=peer_kind)
+            changelog_relationship = RelationshipCardinalityOneChangelog(
+                name=relationship.schema.name,
+                peer_id=peer_id,
+                peer_kind=peer_kind,
+            )
+            if source_id := getattr(relationship, "source_id", None):
+                changelog_relationship.add_property(name="source", value_current=source_id, value_previous=None)
+            if owner_id := getattr(relationship, "owner_id", None):
+                changelog_relationship.add_property(name="owner", value_current=owner_id, value_previous=None)
+            changelog_relationship.add_property(
+                name="is_protected", value_current=relationship.is_protected, value_previous=None
+            )
+            changelog_relationship.add_property(
+                name="is_visible", value_current=relationship.is_visible, value_previous=None
+            )
+            self.relationships[changelog_relationship.name] = changelog_relationship
+        elif relationship.schema.cardinality == RelationshipCardinality.MANY:
+            if relationship.schema.name not in self.relationships:
+                self.relationships[relationship.schema.name] = RelationshipCardinalityManyChangelog(
+                    name=relationship.schema.name
+                )
+            relationship_container = cast(
+                RelationshipCardinalityManyChangelog, self.relationships[relationship.schema.name]
+            )
+
+            relationship_container.add_new_peer(relationship=relationship)
+
+    def delete_relationship(self, relationship: Relationship) -> None:
+        if relationship.schema.cardinality == RelationshipCardinality.ONE:
+            peer_id = relationship.get_peer_id()
+            peer_kind = relationship.get_peer_kind()
+            changelog_relationship = RelationshipCardinalityOneChangelog(
+                name=relationship.schema.name,
+                peer_id_previous=peer_id,
+                peer_kind_previous=peer_kind,
+            )
+            self.relationships[changelog_relationship.name] = changelog_relationship
+        elif relationship.schema.cardinality == RelationshipCardinality.MANY:
+            if relationship.schema.name not in self.relationships:
+                self.relationships[relationship.schema.name] = RelationshipCardinalityManyChangelog(
+                    name=relationship.schema.name
+                )
+            relationship_container = cast(
+                RelationshipCardinalityManyChangelog, self.relationships[relationship.schema.name]
+            )
+            relationship_container.remove_peer(
+                peer_id=relationship.get_peer_id(), peer_kind=relationship.get_peer_kind()
+            )
+
+    def add_attribute(self, attribute: AttributeChangelog) -> None:
+        self.attributes[attribute.name] = attribute
+
+    def add_relationship(
+        self, relationship: RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog
+    ) -> None:
+        if isinstance(relationship, RelationshipCardinalityOneChangelog) and relationship.parent:
+            self.add_parent(parent=relationship.parent)
+        if relationship.is_empty:
+            return
+
+        self.relationships[relationship.name] = relationship
+
+    def create_attribute(self, attribute: BaseAttribute) -> None:
+        changelog_attribute = AttributeChangelog(
+            name=attribute.name, value=attribute.value, value_previous=None, kind=attribute.schema.kind
+        )
+        if source_id := getattr(attribute, "source_id", None):
+            changelog_attribute.add_property(name="source", value_current=source_id, value_previous=None)
+        if owner_id := getattr(attribute, "owner_id", None):
+            changelog_attribute.add_property(name="owner", value_current=owner_id, value_previous=None)
+        changelog_attribute.add_property(name="is_protected", value_current=attribute.is_protected, value_previous=None)
+        changelog_attribute.add_property(name="is_visible", value_current=attribute.is_visible, value_previous=None)
+        self.attributes[changelog_attribute.name] = changelog_attribute
+
+    def get_related_nodes(self) -> list[ChangelogRelatedNode]:
+        related_nodes: dict[str, ChangelogRelatedNode] = {}
+        for relationship in self.relationships.values():
+            if isinstance(relationship, RelationshipCardinalityOneChangelog):
+                if relationship.peer_id and relationship.peer_kind:
+                    related_nodes[relationship.peer_id] = ChangelogRelatedNode(
+                        node_id=relationship.peer_id, node_kind=relationship.peer_kind
+                    )
+                if relationship.peer_id_previous and relationship.peer_kind_previous:
+                    related_nodes[relationship.peer_id_previous] = ChangelogRelatedNode(
+                        node_id=relationship.peer_id_previous, node_kind=relationship.peer_kind_previous
+                    )
+            elif isinstance(relationship, RelationshipCardinalityManyChangelog):
+                for peer in relationship.peers:
+                    related_nodes[peer.peer_id] = ChangelogRelatedNode(node_id=peer.peer_id, node_kind=peer.peer_kind)
+
+        if self.parent:
+            related_nodes[self.parent.node_id] = self.parent
+
+        return list(related_nodes.values())
+
+
+class ChangelogRelationshipMapper:
+    def __init__(self, schema: RelationshipSchema) -> None:
+        self.schema = schema
+        self._cardinality_one_relationship: RelationshipCardinalityOneChangelog | None = None
+        self._cardinality_many_relationship: RelationshipCardinalityManyChangelog | None = None
+
+    @property
+    def cardinality_one_relationship(self) -> RelationshipCardinalityOneChangelog:
+        if not self._cardinality_one_relationship:
+            self._cardinality_one_relationship = RelationshipCardinalityOneChangelog(name=self.schema.name)
+
+        return self._cardinality_one_relationship
+
+    @property
+    def cardinality_many_relationship(self) -> RelationshipCardinalityManyChangelog:
+        if not self._cardinality_many_relationship:
+            self._cardinality_many_relationship = RelationshipCardinalityManyChangelog(name=self.schema.name)
+
+        return self._cardinality_many_relationship
+
+    def remove_peer(self, peer_data: RelationshipPeerData) -> None:
+        if self.schema.cardinality == RelationshipCardinality.ONE:
+            self.cardinality_one_relationship.peer_id_previous = str(peer_data.peer_id)
+            self.cardinality_one_relationship.peer_kind_previous = peer_data.peer_kind
+        elif self.schema.cardinality == RelationshipCardinality.MANY:
+            self.cardinality_many_relationship.remove_peer(
+                peer_id=str(peer_data.peer_id), peer_kind=peer_data.peer_kind
+            )
+
+    def _set_cardinality_one_peer(self, relationship: Relationship) -> None:
+        self.cardinality_one_relationship.peer_id = relationship.peer_id
+        self.cardinality_one_relationship.peer_kind = relationship.get_peer_kind()
+        self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+
+    def add_parent_from_relationship(self, relationship: Relationship) -> None:
+        if self.schema.cardinality == RelationshipCardinality.ONE:
+            self.cardinality_one_relationship.set_parent(
+                parent_id=relationship.get_peer_id(), parent_kind=relationship.get_peer_kind()
+            )
+
+    def add_peer_from_relationship(self, relationship: Relationship) -> None:
+        if self.schema.cardinality == RelationshipCardinality.ONE:
+            self._set_cardinality_one_peer(relationship=relationship)
+        elif self.schema.cardinality == RelationshipCardinality.MANY:
+            self.cardinality_many_relationship.add_new_peer(relationship=relationship)
+
+    def add_updated_relationship(
+        self, relationship: Relationship, old_data: RelationshipPeerData, properties_to_update: list[str]
+    ) -> None:
+        if self.schema.cardinality == RelationshipCardinality.ONE:
+            self._set_cardinality_one_peer(relationship=relationship)
+            self.cardinality_one_relationship.peer_id_previous = self.cardinality_one_relationship.peer_id
+            self.cardinality_one_relationship.peer_kind_previous = self.cardinality_one_relationship.peer_kind
+            for property_to_update in properties_to_update:
+                previous_property = old_data.properties.get(property_to_update)
+                previous_value: str | bool | None = None
+                if previous_property:
+                    if isinstance(previous_property.value, UUID):
+                        previous_value = str(previous_property.value)
+                    else:
+                        previous_value = previous_property.value
+                property_name = (
+                    property_to_update if property_to_update not in ["source", "owner"] else f"{property_to_update}_id"
+                )
+                self.cardinality_one_relationship.add_property(
+                    name=property_to_update,
+                    value_current=getattr(relationship, property_name),
+                    value_previous=previous_value,
+                )
+            self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+
+    def delete_relationship(self, relationship: Relationship) -> None:
+        if self.schema.cardinality == RelationshipCardinality.ONE:
+            self.cardinality_one_relationship.peer_id_previous = relationship.get_peer_id()
+            self.cardinality_one_relationship.peer_kind_previous = relationship.get_peer_kind()
+            self.cardinality_one_relationship.set_parent_from_relationship(relationship=relationship)
+
+        elif self.schema.cardinality == RelationshipCardinality.MANY:
+            self.cardinality_many_relationship.remove_peer(
+                peer_id=relationship.get_peer_id(), peer_kind=relationship.get_peer_kind()
+            )
+
+    @property
+    def changelog(self) -> RelationshipCardinalityOneChangelog | RelationshipCardinalityManyChangelog:
+        match self.schema.cardinality:
+            case RelationshipCardinality.ONE:
+                return self.cardinality_one_relationship
+            case RelationshipCardinality.MANY:
+                return self.cardinality_many_relationship
+
+
+class RelationshipChangelogGetter:
+    def __init__(self, db: InfrahubDatabase, branch: Branch) -> None:
+        self._db = db
+        self._branch = branch
+
+    async def get_changelogs(self, primary_changelog: NodeChangelog) -> list[NodeChangelog]:
+        """Return secondary changelogs based on this update
+
+        These will typically include updates to relationships on other nodes.
+        """
+        schema_branch = self._db.schema.get_schema_branch(name=self._branch.name)
+        node_schema = schema_branch.get(name=primary_changelog.node_kind)
+        secondaries: list[NodeChangelog] = []
+
+        for relationship in primary_changelog.relationships.values():
+            rel_schema = node_schema.get_relationship(name=relationship.name)
+            if isinstance(relationship, RelationshipCardinalityOneChangelog):
+                # For now this code only looks at the scenario when a cardinality=one relationship
+                # is added to a node and it has a cardinality=many relationship coming back from
+                # another node, it will be expanded to include all variations.
+                if relationship.peer_status == DiffAction.ADDED:
+                    peer_schema = schema_branch.get(name=str(relationship.peer_kind))
+                    peer_relation = peer_schema.get_relationship_by_identifier(
+                        id=str(rel_schema.identifier), raise_on_error=False
+                    )
+                    if peer_relation:
+                        node_changelog = NodeChangelog(
+                            node_id=str(relationship.peer_id),
+                            node_kind=str(relationship.peer_kind),
+                            display_label="n/a",
+                        )
+                        if peer_relation.cardinality == RelationshipCardinality.MANY:
+                            node_changelog.relationships[peer_relation.name] = RelationshipCardinalityManyChangelog(
+                                name=peer_relation.name,
+                                peers=[
+                                    RelationshipPeerChangelog(
+                                        peer_id=primary_changelog.node_id,
+                                        peer_kind=primary_changelog.node_kind,
+                                        peer_status=DiffAction.ADDED,
+                                    )
+                                ],
+                            )
+                            secondaries.append(node_changelog)
+
+        return secondaries

infrahub/core/constants/__init__.py

@@ -175,11 +175,23 @@ class GeneratorInstanceStatus(InfrahubStringEnum):
 
 
 class MutationAction(InfrahubStringEnum):
-    ADDED = "added"
-    REMOVED = "removed"
+    CREATED = "created"
+    DELETED = "deleted"
     UPDATED = "updated"
     UNDEFINED = "undefined"
 
+    @classmethod
+    def from_diff_action(cls, diff_action: DiffAction) -> MutationAction:
+        match diff_action:
+            case DiffAction.ADDED:
+                return MutationAction.CREATED
+            case DiffAction.REMOVED:
+                return MutationAction.DELETED
+            case DiffAction.UPDATED:
+                return MutationAction.UPDATED
+            case DiffAction.UNCHANGED:
+                return MutationAction.UNDEFINED
+
 
 class PathResourceType(InfrahubStringEnum):
     SCHEMA = "schema"
@@ -225,6 +237,7 @@ class RelationshipKind(InfrahubStringEnum):
     GROUP = "Group"
     HIERARCHY = "Hierarchy"
     PROFILE = "Profile"
+    TEMPLATE = "Template"
 
 
 class RelationshipStatus(InfrahubStringEnum):
@@ -301,6 +314,7 @@ RESTRICTED_NAMESPACES: list[str] = [
     "Lineage",
     "Schema",
     "Profile",
+    "Template",
 ]
 
 NODE_NAME_REGEX = r"^[A-Z][a-zA-Z0-9]+$"
@@ -315,3 +329,6 @@ DEFAULT_KIND_MAX_LENGTH = 32
 NAMESPACE_REGEX = r"^[A-Z][a-z0-9]+$"
 NODE_KIND_REGEX = r"^[A-Z][a-zA-Z0-9]+$"
 DEFAULT_REL_IDENTIFIER_LENGTH = 128
+
+OBJECT_TEMPLATE_RELATIONSHIP_NAME = "object_template"
+OBJECT_TEMPLATE_NAME_ATTR = "template_name"

infrahub/core/constants/infrahubkind.py

@@ -42,6 +42,7 @@ NUMBERPOOL = "CoreNumberPool"
 LINEAGEOWNER = "LineageOwner"
 LINEAGESOURCE = "LineageSource"
 OBJECTPERMISSION = "CoreObjectPermission"
+OBJECTTEMPLATE = "CoreObjectTemplate"
 OBJECTTHREAD = "CoreObjectThread"
 PASSWORDCREDENTIAL = "CorePasswordCredential"
 PROFILE = "CoreProfile"

infrahub/core/diff/combiner.py

@@ -1,7 +1,6 @@
 from copy import deepcopy
 from dataclasses import dataclass, field, replace
 from typing import Iterable
-from uuid import uuid4
 
 from infrahub.core.constants import NULL_VALUE, DiffAction, RelationshipCardinality
 from infrahub.core.constants.database import DatabaseEdgeType
@@ -342,6 +341,8 @@ class DiffCombiner:
 
     def _copy_node_without_parents(self, node: EnrichedDiffNode) -> EnrichedDiffNode:
         rels_without_parents = {replace(r, nodes=set()) for r in node.relationships}
+        for rel in rels_without_parents:
+            rel.reset_summaries()
         node_without_parents = replace(node, relationships=rels_without_parents)
         return deepcopy(node_without_parents)
 
@@ -351,15 +352,11 @@ class DiffCombiner:
             if node_pair.earlier is None:
                 if node_pair.later is not None:
                     copied = self._copy_node_without_parents(node_pair.later)
-                    for rel in copied.relationships:
-                        rel.reset_summaries()
                     combined_nodes.add(copied)
                 continue
             if node_pair.later is None:
                 if node_pair.earlier is not None:
                     copied = self._copy_node_without_parents(node_pair.earlier)
-                    for rel in copied.relationships:
-                        rel.reset_summaries()
                     combined_nodes.add(copied)
                 continue
             combined_attributes = self._combine_attributes(
@@ -420,18 +417,25 @@ class DiffCombiner:
             filtered_node_pairs = self._filter_nodes_to_keep(earlier_diff=earlier, later_diff=later)
             combined_nodes = self._combine_nodes(node_pairs=filtered_node_pairs)
             self._link_child_nodes(nodes=combined_nodes)
+            if earlier.exists_on_database:
+                diff_uuid = earlier.uuid
+                partner_uuid = earlier.partner_uuid
+            else:
+                diff_uuid = later.uuid
+                partner_uuid = later.partner_uuid
             combined_diffs.append(
                 EnrichedDiffRoot(
-                    uuid=str(uuid4()),
-                    partner_uuid=later.partner_uuid,
+                    uuid=diff_uuid,
+                    partner_uuid=partner_uuid,
                     base_branch_name=later.base_branch_name,
                     diff_branch_name=later.diff_branch_name,
                     from_time=earlier.from_time,
                     to_time=later.to_time,
+                    tracking_id=later.tracking_id,
                     nodes=combined_nodes,
                 )
             )
-        base_branch_diff, diff_branch_diff = combined_diffs  # pylint: disable=unbalanced-tuple-unpacking
+        base_branch_diff, diff_branch_diff = combined_diffs
         base_branch_diff.partner_uuid = diff_branch_diff.uuid
         diff_branch_diff.partner_uuid = base_branch_diff.uuid
         return EnrichedDiffs(