infrahub-server 1.1.6__py3-none-any.whl → 1.1.7__py3-none-any.whl

infrahub/core/attribute.py

@@ -470,6 +470,7 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
         related_node_ids: Optional[set] = None,
         filter_sensitive: bool = False,
         permissions: Optional[dict] = None,
+        include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for this attribute."""
         # pylint: disable=too-many-branches
@@ -480,7 +481,9 @@ class BaseAttribute(FlagPropertyMixin, NodePropertyMixin):
             field_names = fields.keys()
         else:
             # REMOVED updated_at for now, need to investigate further how it's being used today
-            field_names = ["__typename", "value"] + self._node_properties + self._flag_properties
+            field_names = ["__typename", "value"]
+            if include_properties:
+                field_names += self._node_properties + self._flag_properties
 
         for field_name in field_names:
             if field_name == "updated_at":

infrahub/core/branch/tasks.py

@@ -70,14 +70,17 @@ async def rebase_branch(branch: str) -> None:
             service=service,
         )
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
-        enriched_diff = await diff_coordinator.update_branch_diff_and_return(base_branch=base_branch, diff_branch=obj)
-        if enriched_diff.get_all_conflicts():
+        enriched_diff_metadata = await diff_coordinator.update_branch_diff(base_branch=base_branch, diff_branch=obj)
+        async for _ in diff_repository.get_all_conflicts_for_diff(
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
+        ):
+            # if there are any conflicts, raise the error
             raise ValidationError(
                 f"Branch {obj.name} contains conflicts with the default branch that must be addressed."
                 " Please review the diff for details and manually update the conflicts before rebasing."
             )
         node_diff_field_summaries = await diff_repository.get_node_field_summaries(
-            diff_branch_name=enriched_diff.diff_branch_name, diff_id=enriched_diff.uuid
+            diff_branch_name=enriched_diff_metadata.diff_branch_name, diff_id=enriched_diff_metadata.uuid
         )
 
         candidate_schema = merger.get_candidate_schema()
@@ -219,7 +222,7 @@ async def merge_branch(branch: str) -> None:
         # remove tracking ID from the diff because there is no diff after the merge
         # -------------------------------------------------------------
         diff_repository = await component_registry.get_component(DiffRepository, db=db, branch=obj)
-        await diff_repository.drop_tracking_ids(tracking_ids=[BranchTrackingId(name=obj.name)])
+        await diff_repository.mark_tracking_ids_merged(tracking_ids=[BranchTrackingId(name=obj.name)])
 
         # -------------------------------------------------------------
         # Generate an event to indicate that a branch has been merged

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,14 +417,21 @@ 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,
                 )
             )

infrahub/core/diff/coordinator.py

@@ -6,6 +6,7 @@ from uuid import uuid4
 
 from infrahub import lock
 from infrahub.core.timestamp import Timestamp
+from infrahub.exceptions import ValidationError
 from infrahub.log import get_logger
 
 from .model.path import (
@@ -29,7 +30,6 @@ if TYPE_CHECKING:
     from .data_check_synchronizer import DiffDataCheckSynchronizer
     from .enricher.aggregated import AggregatedDiffEnricher
     from .enricher.labels import DiffLabelsEnricher
-    from .enricher.summary_counts import DiffSummaryCountsEnricher
     from .repository.repository import DiffRepository
 
 
@@ -42,7 +42,7 @@ class EnrichedDiffRequest:
     diff_branch: Branch
     from_time: Timestamp
     to_time: Timestamp
-    tracking_id: TrackingId | None = field(default=None)
+    tracking_id: TrackingId
     node_field_specifiers: dict[str, set[str]] = field(default_factory=dict)
 
     def __repr__(self) -> str:
@@ -65,7 +65,6 @@ class DiffCoordinator:
         diff_combiner: DiffCombiner,
         conflicts_enricher: ConflictsEnricher,
         labels_enricher: DiffLabelsEnricher,
-        summary_counts_enricher: DiffSummaryCountsEnricher,
         data_check_synchronizer: DiffDataCheckSynchronizer,
         conflict_transferer: DiffConflictTransferer,
     ) -> None:
@@ -75,7 +74,6 @@ class DiffCoordinator:
         self.diff_combiner = diff_combiner
         self.conflicts_enricher = conflicts_enricher
         self.labels_enricher = labels_enricher
-        self.summary_counts_enricher = summary_counts_enricher
         self.data_check_synchronizer = data_check_synchronizer
         self.conflict_transferer = conflict_transferer
         self.lock_registry = lock.registry
@@ -101,6 +99,8 @@ class DiffCoordinator:
             to_timestamp = Timestamp(to_time)
         else:
             to_timestamp = Timestamp()
+        if not name:
+            raise ValidationError("diff with specified time range requires a name")
         await self.create_or_update_arbitrary_timeframe_diff(
             base_branch=base_branch,
             diff_branch=diff_branch,
@@ -115,27 +115,7 @@ class DiffCoordinator:
             lock_name += "__incremental"
         return lock_name
 
-    async def update_branch_diff_and_return(self, base_branch: Branch, diff_branch: Branch) -> EnrichedDiffRoot:
-        enriched_diff = await self.update_branch_diff(base_branch=base_branch, diff_branch=diff_branch)
-        if isinstance(enriched_diff, EnrichedDiffRoot):
-            return enriched_diff
-        return await self._finalize_diff_root_metadata(diff_root_metadata=enriched_diff)
-
-    async def _finalize_diff_root_metadata(self, diff_root_metadata: EnrichedDiffRootMetadata) -> EnrichedDiffRoot:
-        # if this is EnrichedDiffMetadata, we need to retrieve the full diff and set its metadata to match
-        full_enriched_diff = await self.diff_repo.get_one(
-            diff_branch_name=diff_root_metadata.diff_branch_name, diff_id=diff_root_metadata.uuid
-        )
-        full_enriched_diff.update_metadata(
-            from_time=diff_root_metadata.from_time,
-            to_time=diff_root_metadata.to_time,
-            tracking_id=diff_root_metadata.tracking_id,
-        )
-        return full_enriched_diff
-
-    async def update_branch_diff(
-        self, base_branch: Branch, diff_branch: Branch
-    ) -> EnrichedDiffRoot | EnrichedDiffRootMetadata:
+    async def update_branch_diff(self, base_branch: Branch, diff_branch: Branch) -> EnrichedDiffRootMetadata:
         log.info(f"Received request to update branch diff for {base_branch.name} - {diff_branch.name}")
         incremental_lock_name = self._get_lock_name(
             base_branch_name=base_branch.name, diff_branch_name=diff_branch.name, is_incremental=True
@@ -169,12 +149,6 @@ class DiffCoordinator:
                 tracking_id=tracking_id,
                 force_branch_refresh=False,
             )
-            if not isinstance(enriched_diffs, EnrichedDiffs):
-                await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
-                return enriched_diffs.diff_branch_diff
-
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Branch diff update complete for {base_branch.name} - {diff_branch.name}")
@@ -186,11 +160,9 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        name: str | None = None,
-    ) -> EnrichedDiffRoot:
-        tracking_id = None
-        if name:
-            tracking_id = NameTrackingId(name=name)
+        name: str,
+    ) -> EnrichedDiffRootMetadata:
+        tracking_id = NameTrackingId(name=name)
         general_lock_name = self._get_lock_name(
             base_branch_name=base_branch.name, diff_branch_name=diff_branch.name, is_incremental=False
         )
@@ -204,13 +176,7 @@ class DiffCoordinator:
                 tracking_id=tracking_id,
                 force_branch_refresh=False,
             )
-            # metadata-only diff, so no nodes to enrich
-            if not isinstance(enriched_diffs, EnrichedDiffs):
-                await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
-                return await self._finalize_diff_root_metadata(diff_root_metadata=enriched_diffs.diff_branch_diff)
 
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Arbitrary diff update complete for {base_branch.name} - {diff_branch.name}")
@@ -252,8 +218,6 @@ class DiffCoordinator:
                     earlier=current_branch_diff, later=enriched_diffs.diff_branch_diff
                 )
 
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff)
-            await self.summary_counts_enricher.enrich(enriched_diff_root=enriched_diffs.diff_branch_diff)
             await self.diff_repo.save(enriched_diffs=enriched_diffs)
             await self._update_core_data_checks(enriched_diff=enriched_diffs.diff_branch_diff)
             log.info(f"Diff recalculation complete for {base_branch.name} - {diff_branch.name}")
@@ -316,7 +280,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: Literal[True] = ...,
     ) -> EnrichedDiffs: ...
 
@@ -327,7 +291,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: Literal[False] = ...,
     ) -> EnrichedDiffs | EnrichedDiffsMetadata: ...
 
@@ -337,7 +301,7 @@ class DiffCoordinator:
         diff_branch: Branch,
         from_time: Timestamp,
         to_time: Timestamp,
-        tracking_id: TrackingId | None = None,
+        tracking_id: TrackingId,
         force_branch_refresh: bool = False,
     ) -> EnrichedDiffs | EnrichedDiffsMetadata:
         # start with empty diffs b/c we only care about their metadata for now, hydrate them with data as needed
@@ -346,6 +310,7 @@ class DiffCoordinator:
             diff_branch_names=[diff_branch.name],
             from_time=from_time,
             to_time=to_time,
+            tracking_id=tracking_id,
         )
         aggregated_enriched_diffs = await self._aggregate_enriched_diffs(
             diff_request=EnrichedDiffRequest(
@@ -357,22 +322,23 @@ class DiffCoordinator:
             ),
             partial_enriched_diffs=diff_pairs_metadata if not force_branch_refresh else None,
         )
-        if tracking_id:
-            diff_uuids_to_delete: list[str] = []
-            for diff_pair in diff_pairs_metadata:
-                if (
-                    diff_pair.base_branch_diff.tracking_id == tracking_id
-                    and diff_pair.base_branch_diff.uuid != aggregated_enriched_diffs.base_branch_diff.uuid
-                ):
-                    diff_uuids_to_delete.append(diff_pair.base_branch_diff.uuid)
-                if (
-                    diff_pair.diff_branch_diff.tracking_id == tracking_id
-                    and diff_pair.diff_branch_diff.uuid != aggregated_enriched_diffs.diff_branch_diff.uuid
-                ):
-                    diff_uuids_to_delete.append(diff_pair.diff_branch_diff.uuid)
-
-            if diff_uuids_to_delete:
-                await self.diff_repo.delete_diff_roots(diff_root_uuids=diff_uuids_to_delete)
+        diff_uuids_to_delete: list[str] = []
+        for diff_pair in diff_pairs_metadata:
+            if (
+                diff_pair.base_branch_diff.tracking_id == tracking_id
+                and diff_pair.base_branch_diff.uuid != aggregated_enriched_diffs.base_branch_diff.uuid
+                and diff_pair.base_branch_diff.exists_on_database
+            ):
+                diff_uuids_to_delete.append(diff_pair.base_branch_diff.uuid)
+            if (
+                diff_pair.diff_branch_diff.tracking_id == tracking_id
+                and diff_pair.diff_branch_diff.uuid != aggregated_enriched_diffs.diff_branch_diff.uuid
+                and diff_pair.diff_branch_diff.exists_on_database
+            ):
+                diff_uuids_to_delete.append(diff_pair.diff_branch_diff.uuid)
+
+        if diff_uuids_to_delete:
+            await self.diff_repo.delete_diff_roots(diff_root_uuids=diff_uuids_to_delete)
 
         # this is an EnrichedDiffsMetadata, so there are no nodes to enrich
         if not isinstance(aggregated_enriched_diffs, EnrichedDiffs):
@@ -459,6 +425,7 @@ class DiffCoordinator:
                         diff_branch=diff_request.diff_branch,
                         from_time=current_time,
                         to_time=end_time,
+                        tracking_id=diff_request.tracking_id,
                     )
                 )
                 current_time = end_time
@@ -481,7 +448,6 @@ class DiffCoordinator:
         aggregated_enriched_diffs.update_metadata(
             from_time=diff_request.from_time, to_time=diff_request.to_time, tracking_id=diff_request.tracking_id
         )
-        aggregated_enriched_diffs.set_fresh_uuids()
         return aggregated_enriched_diffs
 
     async def _concatenate_diffs_and_requests(
@@ -498,6 +464,7 @@ class DiffCoordinator:
             meaning multiple diffs (some that may have been freshly calculated) were combined
         """
         previous_diff_pair: EnrichedDiffs | EnrichedDiffsMetadata | None = None
+        updated_node_uuids: set[str] = set()
         for diff_or_request in diff_or_request_list:
             if isinstance(diff_or_request, EnrichedDiffRequest):
                 if previous_diff_pair:
@@ -508,9 +475,12 @@ class DiffCoordinator:
                     log.info(f"Number node field specifiers: {len(node_field_specifiers)}")
                     diff_or_request.node_field_specifiers = node_field_specifiers
                 is_incremental_diff = diff_or_request.from_time != full_diff_request.from_time
-                single_enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata = await self._calculate_enriched_diff(
+                calculated_diff = await self._calculate_enriched_diff(
                     diff_request=diff_or_request, is_incremental_diff=is_incremental_diff
                 )
+                updated_node_uuids |= calculated_diff.base_node_uuids
+                updated_node_uuids |= calculated_diff.branch_node_uuids
+                single_enriched_diffs: EnrichedDiffs | EnrichedDiffsMetadata = calculated_diff
 
             elif isinstance(diff_or_request, EnrichedDiffsMetadata):
                 single_enriched_diffs = diff_or_request
@@ -522,13 +492,20 @@ class DiffCoordinator:
                 continue
 
             log.info("Combining diffs...")
-            previous_diff_pair = await self._combine_diffs(earlier=previous_diff_pair, later=single_enriched_diffs)
+            previous_diff_pair = await self._combine_diffs(
+                earlier=previous_diff_pair,
+                later=single_enriched_diffs,
+                node_uuids=updated_node_uuids,
+            )
             log.info("Diffs combined.")
 
         return previous_diff_pair
 
     async def _combine_diffs(
-        self, earlier: EnrichedDiffs | EnrichedDiffsMetadata, later: EnrichedDiffs | EnrichedDiffsMetadata
+        self,
+        earlier: EnrichedDiffs | EnrichedDiffsMetadata,
+        later: EnrichedDiffs | EnrichedDiffsMetadata,
+        node_uuids: set[str],
     ) -> EnrichedDiffs | EnrichedDiffsMetadata:
         log.info(f"Earlier diff to combine: {earlier!r}")
         log.info(f"Later diff to combine: {later!r}")
@@ -545,11 +522,11 @@ class DiffCoordinator:
         # hydrate the diffs to combine, if necessary
         if not isinstance(earlier, EnrichedDiffs):
             log.info("Hydrating earlier diff...")
-            earlier = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=earlier)
+            earlier = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=earlier, node_uuids=node_uuids)
             log.info("Earlier diff hydrated.")
         if not isinstance(later, EnrichedDiffs):
             log.info("Hydrating later diff...")
-            later = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=later)
+            later = await self.diff_repo.hydrate_diff_pair(enriched_diffs_metadata=later, node_uuids=node_uuids)
             log.info("Later diff hydrated.")
 
         return await self.diff_combiner.combine(earlier_diffs=earlier, later_diffs=later)
@@ -570,6 +547,8 @@ class DiffCoordinator:
             previous_node_specifiers=diff_request.node_field_specifiers,
         )
         log.info("Calculation complete. Enriching diff...")
-        enriched_diff_pair = await self.diff_enricher.enrich(calculated_diffs=calculated_diff_pair)
+        enriched_diff_pair = await self.diff_enricher.enrich(
+            calculated_diffs=calculated_diff_pair, tracking_id=diff_request.tracking_id
+        )
         log.info("Enrichment complete")
         return enriched_diff_pair

infrahub/core/diff/data_check_synchronizer.py

@@ -10,7 +10,13 @@ from infrahub.proposed_change.constants import ProposedChangeState
 
 from .conflicts_extractor import DiffConflictsExtractor
 from .model.diff import DataConflict
-from .model.path import ConflictSelection, EnrichedDiffConflict, EnrichedDiffRoot, EnrichedDiffRootMetadata
+from .model.path import (
+    ConflictSelection,
+    EnrichedDiffConflict,
+    EnrichedDiffNode,
+    EnrichedDiffRoot,
+    EnrichedDiffRootMetadata,
+)
 from .repository.repository import DiffRepository
 
 
@@ -54,20 +60,31 @@ class DiffDataCheckSynchronizer:
         if not proposed_changes:
             return []
         all_data_checks = []
+        enriched_diff_all_conflicts: EnrichedDiffRoot | None = None
         for pc in proposed_changes:
             # if the enriched_diff is EnrichedDiffRootMetadata, then it has no new data in it
             if not isinstance(enriched_diff, EnrichedDiffRoot):
                 has_validator = bool(await self.conflict_recorder.get_validator(proposed_change=pc))
-                # if this pc does not have a validator, then it is a new ProposedChange
+                # if this pc has a validator, then the conflicts for this diff have already been synchronized and we can be done
                 if has_validator:
                     continue
-                # if this is a new ProposedChange, we need to hydrate then EnrichedDiffRoot so that we can get the conflicts from it
-                enriched_diff = await self.diff_repository.get_one(
-                    diff_branch_name=enriched_diff.diff_branch_name, diff_id=enriched_diff.uuid
+
+            # we need to get the conflicts for this diff from the database b/c `enriched_diff` might not include all nodes
+            if not enriched_diff_all_conflicts:
+                retrieved_diff_conflicts_only = await self.diff_repository.get_one(
+                    diff_branch_name=enriched_diff.diff_branch_name,
+                    diff_id=enriched_diff.uuid,
+                    filters={"only_conflicted": True},
                 )
+                enriched_diff_all_conflicts = retrieved_diff_conflicts_only
+                # if `enriched_diff` is an EnrichedDiffRootsMetadata, then there have been no changes to the diff and
+                # we can use `retrieved_diff_conflicts_only`
+                # otherwise, we need to combine the changes to `enriched_diff` with the conflicts from the database
+                if isinstance(enriched_diff, EnrichedDiffRoot):
+                    self._update_diff_conflicts(updated_diff=enriched_diff, retrieved_diff=enriched_diff_all_conflicts)
 
-            data_conflicts = await self._get_data_conflicts(enriched_diff=enriched_diff)
-            enriched_conflicts_map = self._get_enriched_conflicts_map(enriched_diff=enriched_diff)
+            data_conflicts = await self._get_data_conflicts(enriched_diff=enriched_diff_all_conflicts)
+            enriched_conflicts_map = self._get_enriched_conflicts_map(enriched_diff=enriched_diff_all_conflicts)
             core_data_checks = await self.conflict_recorder.record_conflicts(
                 proposed_change_id=pc.get_id(), conflicts=data_conflicts
             )
@@ -95,3 +112,65 @@ class DiffDataCheckSynchronizer:
         if enriched_conflict.selected_branch is ConflictSelection.DIFF_BRANCH:
             return BranchConflictKeep.SOURCE
         return None
+
+    def _update_diff_conflicts(self, updated_diff: EnrichedDiffRoot, retrieved_diff: EnrichedDiffRoot) -> None:
+        for updated_node in updated_diff.nodes:
+            try:
+                retrieved_node = retrieved_diff.get_node(node_uuid=updated_node.uuid)
+            except ValueError:
+                retrieved_node = None
+            if not retrieved_node:
+                retrieved_diff.nodes.add(updated_node)
+                continue
+            retrieved_node.conflict = updated_node.conflict
+            self._update_diff_attr_conflicts(updated_node=updated_node, retrieved_node=retrieved_node)
+            self._update_diff_relationship_conflicts(updated_node=updated_node, retrieved_node=retrieved_node)
+
+    def _update_diff_attr_conflicts(self, updated_node: EnrichedDiffNode, retrieved_node: EnrichedDiffNode) -> None:
+        for updated_attr in updated_node.attributes:
+            try:
+                retrieved_attr = retrieved_node.get_attribute(name=updated_attr.name)
+            except ValueError:
+                retrieved_attr = None
+            if not retrieved_attr:
+                retrieved_node.attributes.add(updated_attr)
+                continue
+            for updated_prop in updated_attr.properties:
+                try:
+                    retrieved_prop = retrieved_attr.get_property(updated_prop.property_type)
+                except ValueError:
+                    retrieved_prop = None
+                if not retrieved_prop:
+                    retrieved_attr.properties.add(updated_prop)
+                    continue
+                retrieved_prop.conflict = updated_prop.conflict
+
+    def _update_diff_relationship_conflicts(
+        self, updated_node: EnrichedDiffNode, retrieved_node: EnrichedDiffNode
+    ) -> None:
+        for updated_rel in updated_node.relationships:
+            try:
+                retrieved_rel = retrieved_node.get_relationship(name=updated_rel.name)
+            except ValueError:
+                retrieved_rel = None
+            if not retrieved_rel:
+                retrieved_node.relationships.add(updated_rel)
+                continue
+            for updated_element in updated_rel.relationships:
+                try:
+                    retrieved_element = retrieved_rel.get_element(updated_element.peer_id)
+                except ValueError:
+                    retrieved_element = None
+                if not retrieved_element:
+                    retrieved_rel.relationships.add(updated_element)
+                    continue
+                retrieved_element.conflict = updated_element.conflict
+                for updated_prop in updated_element.properties:
+                    try:
+                        retrieved_prop = retrieved_element.get_property(updated_prop.property_type)
+                    except ValueError:
+                        retrieved_prop = None
+                    if not retrieved_prop:
+                        retrieved_element.properties.add(updated_prop)
+                        continue
+                    retrieved_prop.conflict = updated_prop.conflict

infrahub/core/diff/enricher/aggregated.py

@@ -1,4 +1,4 @@
-from ..model.path import CalculatedDiffs, EnrichedDiffs
+from ..model.path import CalculatedDiffs, EnrichedDiffs, TrackingId
 from .interface import DiffEnricherInterface
 
 
@@ -6,8 +6,8 @@ class AggregatedDiffEnricher:
     def __init__(self, enrichers: list[DiffEnricherInterface]) -> None:
         self.enrichers = enrichers
 
-    async def enrich(self, calculated_diffs: CalculatedDiffs) -> EnrichedDiffs:
-        enriched_diffs = EnrichedDiffs.from_calculated_diffs(calculated_diffs=calculated_diffs)
+    async def enrich(self, calculated_diffs: CalculatedDiffs, tracking_id: TrackingId) -> EnrichedDiffs:
+        enriched_diffs = EnrichedDiffs.from_calculated_diffs(calculated_diffs=calculated_diffs, tracking_id=tracking_id)
 
         for enricher in self.enrichers:
             await enricher.enrich(enriched_diff_root=enriched_diffs.base_branch_diff, calculated_diffs=calculated_diffs)

infrahub/core/diff/enricher/cardinality_one.py

@@ -103,14 +103,9 @@ class DiffCardinalityOneEnricher(DiffEnricherInterface):
                 )
             )
         if consolidated_properties:
-            element_timestamps = {element.changed_at for element in diff_relationship.relationships}
             element_actions = {element.action for element in diff_relationship.relationships}
             # check if this is a simultaneous update
-            if (
-                len(diff_relationship.relationships) > 1
-                and len(element_timestamps) == 1
-                and {DiffAction.REMOVED, DiffAction.ADDED} <= element_actions
-            ):
+            if len(diff_relationship.relationships) > 1 and {DiffAction.REMOVED, DiffAction.ADDED} <= element_actions:
                 latest_element = [
                     element for element in diff_relationship.relationships if element.action is DiffAction.ADDED
                 ][0]

infrahub/core/diff/enricher/labels.py

@@ -154,10 +154,20 @@ class DiffLabelsEnricher(DiffEnricherInterface):
         for node in enriched_diff.nodes:
             if not node.relationships:
                 continue
-            node_schema = self.db.schema.get(name=node.kind, branch=self.diff_branch_name, duplicate=False)
+
+            node_schema = self.db.schema.get(name=node.kind, branch=enriched_diff.diff_branch_name, duplicate=False)
+            alternate_node_schema = None
+            if enriched_diff.diff_branch_name != enriched_diff.base_branch_name and self.db.schema.has(
+                name=node.kind, branch=enriched_diff.base_branch_name
+            ):
+                alternate_node_schema = self.db.schema.get(
+                    name=node.kind, branch=enriched_diff.base_branch_name, duplicate=False
+                )
             for relationship_diff in node.relationships:
-                relationship_schema = node_schema.get_relationship(name=relationship_diff.name)
-                relationship_diff.label = relationship_schema.label or ""
+                relationship_schema = node_schema.get_relationship_or_none(name=relationship_diff.name)
+                if not relationship_schema and alternate_node_schema:
+                    relationship_schema = alternate_node_schema.get_relationship_or_none(name=relationship_diff.name)
+                relationship_diff.label = relationship_schema.label or "" if relationship_schema else ""
 
     async def _get_display_label_map(
         self, display_label_requests: set[DisplayLabelRequest]

infrahub/core/diff/enricher/path_identifier.py

@@ -1,4 +1,4 @@
-from infrahub.core.constants import PathType, RelationshipCardinality
+from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath
 from infrahub.database import InfrahubDatabase
 
@@ -44,14 +44,8 @@ class DiffPathIdentifierEnricher(DiffEnricherInterface):
                     attribute_property.path_identifier = property_path.get_path()
             if not node.relationships:
                 continue
-            node_schema = self.db.schema.get(name=node.kind, branch=self.diff_branch_name, duplicate=False)
             for relationship in node.relationships:
-                relationship_schema = node_schema.get_relationship(name=relationship.name)
-                path_type = (
-                    PathType.RELATIONSHIP_ONE
-                    if relationship_schema.cardinality is RelationshipCardinality.ONE
-                    else PathType.RELATIONSHIP_MANY
-                )
+                path_type = PathType.from_relationship(relationship.cardinality)
                 relationship_path = DataPath(
                     branch=enriched_diff_root.diff_branch_name,
                     path_type=path_type,

infrahub/core/diff/merger/merger.py

@@ -34,13 +34,15 @@ class DiffMerger:
         self.serializer = serializer
 
     async def merge_graph(self, at: Timestamp) -> None:
+        tracking_id = BranchTrackingId(name=self.source_branch.name)
         enriched_diffs = await self.diff_repository.get_roots_metadata(
-            diff_branch_names=[self.source_branch.name], base_branch_names=[self.destination_branch.name]
+            diff_branch_names=[self.source_branch.name],
+            base_branch_names=[self.destination_branch.name],
+            tracking_id=tracking_id,
         )
         latest_diff = None
-        tracking_id = BranchTrackingId(name=self.source_branch.name)
         for diff in enriched_diffs:
-            if latest_diff is None or (diff.tracking_id == tracking_id and diff.to_time > latest_diff.to_time):
+            if latest_diff is None or (diff.to_time > latest_diff.to_time):
                 latest_diff = diff
         if latest_diff is None:
             raise RuntimeError(f"Missing diff for branch {self.source_branch.name}")