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

infrahub/core/diff/model/path.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field, replace
+from dataclasses import asdict, dataclass, field
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional
-from uuid import uuid4
 
 from infrahub.core.constants import (
     BranchSupportType,
@@ -171,6 +170,12 @@ class EnrichedDiffAttribute(BaseSummary):
         for prop in self.properties:
             prop.conflict = None
 
+    def get_property(self, property_type: DatabaseEdgeType) -> EnrichedDiffProperty:
+        for prop in self.properties:
+            if prop.property_type is property_type:
+                return prop
+        raise ValueError(f"No {property_type.value} property found")
+
     @classmethod
     def from_calculated_attribute(cls, calculated_attribute: DiffAttribute) -> EnrichedDiffAttribute:
         return EnrichedDiffAttribute(
@@ -253,6 +258,12 @@ class EnrichedDiffRelationship(BaseSummary):
         for element in self.relationships:
             element.clear_conflicts()
 
+    def get_element(self, peer_id: str) -> EnrichedDiffSingleRelationship:
+        for element in self.relationships:
+            if element.peer_id == peer_id:
+                return element
+        raise ValueError(f"No relationship for {peer_id} found")
+
     @property
     def include_in_response(self) -> bool:
         if self.action == DiffAction.UNCHANGED and not self.relationships:
@@ -314,18 +325,18 @@ class EnrichedDiffNode(BaseSummary):
             rel.clear_conflicts()
         self.conflict = None
 
-    def get_parent_info(self, context: GraphqlContext | None = None) -> ParentNodeInfo | None:
+    def get_parent_info(self, graphql_context: GraphqlContext | None = None) -> ParentNodeInfo | None:
         for r in self.relationships:
             for n in r.nodes:
                 relationship_name: str = "undefined"
 
-                if not context:
+                if not graphql_context:
                     return ParentNodeInfo(node=n, relationship_name=relationship_name)
 
-                node_schema = context.db.schema.get(name=self.kind)
+                node_schema = graphql_context.db.schema.get(name=self.kind)
                 rel_schema = node_schema.get_relationship(name=r.name)
 
-                parent_schema = context.db.schema.get(name=n.kind)
+                parent_schema = graphql_context.db.schema.get(name=n.kind)
                 rels_parent = parent_schema.get_relationships_by_identifier(id=rel_schema.get_identifier())
 
                 if rels_parent and len(rels_parent) == 1:
@@ -353,16 +364,11 @@ class EnrichedDiffNode(BaseSummary):
                 all_children |= n.get_all_child_nodes()
         return all_children
 
-    def get_trimmed_node(self, max_depth: int) -> EnrichedDiffNode:
-        trimmed = replace(self, relationships=set())
-        for rel in self.relationships:
-            trimmed_rel = replace(rel, nodes=set())
-            trimmed.relationships.add(trimmed_rel)
-            if max_depth == 0:
-                continue
-            for child_node in rel.nodes:
-                trimmed_rel.nodes.add(child_node.get_trimmed_node(max_depth=max_depth - 1))
-        return trimmed
+    def get_attribute(self, name: str) -> EnrichedDiffAttribute:
+        for attr in self.attributes:
+            if attr.name == name:
+                return attr
+        raise ValueError(f"No attribute {name} found")
 
     def get_relationship(self, name: str) -> EnrichedDiffRelationship:
         for rel in self.relationships:
@@ -404,7 +410,8 @@ class EnrichedDiffRootMetadata(BaseSummary):
     to_time: Timestamp
     uuid: str
     partner_uuid: str
-    tracking_id: TrackingId | None = field(default=None, kw_only=True)
+    tracking_id: TrackingId
+    exists_on_database: bool = field(default=False)
 
     def __hash__(self) -> int:
         return hash(self.uuid)
@@ -426,7 +433,7 @@ class EnrichedDiffRootMetadata(BaseSummary):
         if to_time and self.to_time != to_time:
             self.to_time = to_time
             is_changed = True
-        if self.tracking_id != tracking_id:
+        if self.tracking_id != tracking_id and tracking_id is not None:
             self.tracking_id = tracking_id
             is_changed = True
         return is_changed
@@ -475,7 +482,11 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
 
     @classmethod
     def from_calculated_diff(
-        cls, calculated_diff: DiffRoot, base_branch_name: str, partner_uuid: str
+        cls,
+        calculated_diff: DiffRoot,
+        base_branch_name: str,
+        partner_uuid: str,
+        tracking_id: TrackingId,
     ) -> EnrichedDiffRoot:
         return EnrichedDiffRoot(
             base_branch_name=base_branch_name,
@@ -484,6 +495,7 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
             to_time=calculated_diff.to_time,
             uuid=calculated_diff.uuid,
             partner_uuid=partner_uuid,
+            tracking_id=tracking_id,
             nodes={EnrichedDiffNode.from_calculated_node(calculated_node=n) for n in calculated_diff.nodes},
         )
 
@@ -563,14 +575,6 @@ class EnrichedDiffsMetadata:
         )
         return is_changed
 
-    def set_fresh_uuids(self) -> None:
-        base_uuid = str(uuid4())
-        branch_uuid = str(uuid4())
-        self.base_branch_diff.uuid = base_uuid
-        self.base_branch_diff.partner_uuid = branch_uuid
-        self.diff_branch_diff.uuid = branch_uuid
-        self.diff_branch_diff.partner_uuid = base_uuid
-
 
 @dataclass
 class EnrichedDiffs(EnrichedDiffsMetadata):
@@ -591,16 +595,18 @@ class EnrichedDiffs(EnrichedDiffsMetadata):
         )
 
     @classmethod
-    def from_calculated_diffs(cls, calculated_diffs: CalculatedDiffs) -> EnrichedDiffs:
+    def from_calculated_diffs(cls, calculated_diffs: CalculatedDiffs, tracking_id: TrackingId) -> EnrichedDiffs:
         base_branch_diff = EnrichedDiffRoot.from_calculated_diff(
             calculated_diff=calculated_diffs.base_branch_diff,
             base_branch_name=calculated_diffs.base_branch_name,
             partner_uuid=calculated_diffs.diff_branch_diff.uuid,
+            tracking_id=tracking_id,
         )
         diff_branch_diff = EnrichedDiffRoot.from_calculated_diff(
             calculated_diff=calculated_diffs.diff_branch_diff,
             base_branch_name=calculated_diffs.base_branch_name,
             partner_uuid=calculated_diffs.base_branch_diff.uuid,
+            tracking_id=tracking_id,
         )
         return EnrichedDiffs(
             base_branch_name=calculated_diffs.base_branch_name,
@@ -613,6 +619,14 @@ class EnrichedDiffs(EnrichedDiffsMetadata):
     def is_empty(self) -> bool:
         return len(self.base_branch_diff.nodes) == 0 and len(self.diff_branch_diff.nodes) == 0
 
+    @property
+    def base_node_uuids(self) -> set[str]:
+        return {n.uuid for n in self.base_branch_diff.nodes}
+
+    @property
+    def branch_node_uuids(self) -> set[str]:
+        return {n.uuid for n in self.diff_branch_diff.nodes}
+
 
 @dataclass
 class CalculatedDiffs:
@@ -678,7 +692,7 @@ class DiffRoot:
 
 
 @dataclass
-class DatabasePath:  # pylint: disable=too-many-public-methods
+class DatabasePath:
     root_node: Neo4jNode
     path_to_node: Neo4jRelationship
     node_node: Neo4jNode
@@ -739,6 +753,10 @@ class DatabasePath:  # pylint: disable=too-many-public-methods
     def node_id(self) -> str:
         return str(self.node_node.get("uuid"))
 
+    @property
+    def node_db_id(self) -> str:
+        return self.node_node.element_id
+
     @property
     def node_kind(self) -> str:
         return str(self.node_node.get("kind"))

infrahub/core/diff/query/all_conflicts.py

@@ -24,7 +24,7 @@ class EnrichedDiffAllConflictsQuery(Query):
         if self.tracking_id is None and self.diff_id is None:
             raise RuntimeError("tracking_id or diff_id is required")
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    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,
@@ -32,8 +32,11 @@ class EnrichedDiffAllConflictsQuery(Query):
         }
         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)
+WHERE (root.is_merged IS NULL OR root.is_merged <> TRUE)
+AND (
+    ($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)
+)
 CALL {
     WITH root
     MATCH (root)-[:DIFF_HAS_NODE]->(node:DiffNode)-[:DIFF_HAS_CONFLICT]->(node_conflict:DiffConflict)

infrahub/core/diff/query/artifact.py

@@ -22,7 +22,7 @@ class ArtifactDiffQuery(Query):
         self.target_rel_identifier = target_rel_identifier
         self.definition_rel_identifier = definition_rel_identifier
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         source_branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
 

infrahub/core/diff/query/delete_query.py

@@ -13,7 +13,7 @@ class EnrichedDiffDeleteQuery(Query):
         super().__init__(**kwargs)
         self.enriched_diff_root_uuids = enriched_diff_root_uuids
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"diff_root_uuids": self.enriched_diff_root_uuids}
         query = """
         MATCH (d_root:DiffRoot)

infrahub/core/diff/query/diff_get.py

@@ -11,7 +11,8 @@ from .filters import EnrichedDiffQueryFilters
 QUERY_MATCH_NODES = """
     // 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 IN $diff_branches
     AND ($from_time IS NULL OR diff_root.from_time >= $from_time)
     AND ($to_time IS NULL OR diff_root.to_time <= $to_time)
@@ -51,7 +52,7 @@ class EnrichedDiffGetQuery(Query):
         self.diff_ids = diff_ids
         self.filters = filters or EnrichedDiffQueryFilters()
 
-    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_branches": self.diff_branch_names,

infrahub/core/diff/query/diff_summary.py

@@ -61,7 +61,7 @@ class DiffSummaryQuery(Query):
         self.to_time = to_time
         self.tracking_id = tracking_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         if (self.from_time is None or self.to_time is None) and self.tracking_id is None:
             raise ValueError("DiffSummaryQuery requires from_time and to_time or tracking_id ")
         self.params = {

infrahub/core/diff/query/field_specifiers.py

@@ -12,14 +12,16 @@ class EnrichedDiffFieldSpecifiersQuery(Query):
         super().__init__(**kwargs)
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["diff_id"] = self.diff_id
         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
     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
 }
         """

infrahub/core/diff/query/field_summary.py

@@ -27,7 +27,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         self.tracking_id = tracking_id
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         if self.tracking_id is None and self.diff_id is None:
             raise RuntimeError("Either tacking_id or diff_id is required")
         self.params = {
@@ -38,7 +38,8 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         }
         query = """
         MATCH (diff_root:DiffRoot)
-        WHERE diff_root.diff_branch = $diff_branch
+        WHERE (diff_root.is_merged IS NULL OR diff_root.is_merged <> TRUE)
+        AND diff_root.diff_branch = $diff_branch
         AND (diff_root.tracking_id = $tracking_id OR $tracking_id IS NULL)
         AND (diff_root.uuid = $diff_id OR $diff_id IS NULL)
         OPTIONAL MATCH (diff_root)-[:DIFF_HAS_NODE]->(n:DiffNode)

infrahub/core/diff/query/filters.py

@@ -31,10 +31,17 @@ class EnrichedDiffQueryFilters(BaseModel):
     kind: IncExclFilterOptions = IncExclFilterOptions()
     namespace: IncExclFilterOptions = IncExclFilterOptions()
     status: IncExclActionFilterOptions = IncExclActionFilterOptions()
+    only_conflicted: bool = Field(default=False)
 
     @property
     def is_empty(self) -> bool:
-        if not self.ids and self.kind.is_empty and self.namespace.is_empty and self.status.is_empty:
+        if (
+            not self.ids
+            and self.only_conflicted is False
+            and self.kind.is_empty
+            and self.namespace.is_empty
+            and self.status.is_empty
+        ):
             return True
         return False
 
@@ -91,4 +98,8 @@ class EnrichedDiffQueryFilters(BaseModel):
 
             filters_list.append(filter_and(filter_action))
 
+        # ONLY NODES WITH CONFLICTS
+        if self.only_conflicted is True:
+            filters_list.append("diff_node.contains_conflict = TRUE")
+
         return filter_and(filters_list), params

infrahub/core/diff/query/get_conflict_query.py

@@ -14,7 +14,7 @@ class EnrichedDiffConflictQuery(Query):
         super().__init__(**kwargs)
         self.conflict_id = conflict_id
 
-    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}
         query = "MATCH (conflict:DiffConflict {uuid: $conflict_id})"
         self.return_labels = ["conflict"]

infrahub/core/diff/query/has_conflicts_query.py

@@ -25,7 +25,7 @@ class EnrichedDiffHasConflictQuery(Query):
         self.tracking_id = tracking_id
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "diff_branch_name": self.diff_branch_name,
             "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
@@ -33,8 +33,11 @@ class EnrichedDiffHasConflictQuery(Query):
         }
         query = """
 MATCH (diff_root:DiffRoot)
-WHERE ($diff_id IS NOT NULL AND diff_root.uuid = $diff_id)
-OR ($tracking_id IS NOT NULL AND diff_root.tracking_id = $tracking_id AND diff_root.diff_branch = $diff_branch_name)
+WHERE (diff_root.is_merged IS NULL OR diff_root.is_merged <> TRUE)
+AND (
+    ($diff_id IS NOT NULL AND diff_root.uuid = $diff_id)
+    OR ($tracking_id IS NOT NULL AND diff_root.tracking_id = $tracking_id AND diff_root.diff_branch = $diff_branch_name)
+)
 WITH (
     exists(
         (diff_root)-[:DIFF_HAS_NODE]->(:DiffNode)-[:DIFF_HAS_CONFLICT]->(:DiffConflict)

infrahub/core/diff/query/merge.py

@@ -28,7 +28,7 @@ class DiffMergeQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "node_diff_dicts": self.node_diff_dicts,
             "at": self.at.to_string(),
@@ -339,7 +339,7 @@ class DiffMergePropertiesQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "property_diff_dicts": self.property_diff_dicts,
             "at": self.at.to_string(),
@@ -514,7 +514,7 @@ class DiffMergeRollbackQuery(Query):
         self.target_branch = target_branch
         self.source_branch_name = self.branch.name
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "at": self.at.to_string(),
             "target_branch": self.target_branch.name,

infrahub/core/diff/query/{drop_tracking_id.py → merge_tracking_id.py}

@@ -6,8 +6,8 @@ from infrahub.database import InfrahubDatabase
 from ..model.path import TrackingId
 
 
-class EnrichedDiffDropTrackingIdQuery(Query):
-    name = "enriched_diff_drop_tracking_id"
+class EnrichedDiffMergedTrackingIdQuery(Query):
+    name = "enriched_diff_merge_tracking_id"
     type = QueryType.WRITE
     insert_return = False
 
@@ -15,11 +15,11 @@ class EnrichedDiffDropTrackingIdQuery(Query):
         super().__init__(**kwargs)
         self.tracking_ids = tracking_ids
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"tracking_ids": [t_id.serialize() for t_id in self.tracking_ids]}
         query = """
         MATCH (d_root:DiffRoot)
         WHERE d_root.tracking_id IN $tracking_ids
-        SET d_root.tracking_id = NULL
+        SET d_root.is_merged = TRUE
         """
         self.add_to_query(query=query)

infrahub/core/diff/query/roots_metadata.py

@@ -6,6 +6,8 @@ from infrahub.core.query import Query, QueryType
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 
+from ..model.path import TrackingId
+
 
 class EnrichedDiffRootsMetadataQuery(Query):
     name = "enriched_diff_roots_metadata"
@@ -17,6 +19,7 @@ class EnrichedDiffRootsMetadataQuery(Query):
         base_branch_names: list[str] | None = None,
         from_time: Timestamp | None = None,
         to_time: Timestamp | None = None,
+        tracking_id: TrackingId | None = None,
         **kwargs: Any,
     ) -> None:
         super().__init__(**kwargs)
@@ -24,21 +27,25 @@ class EnrichedDiffRootsMetadataQuery(Query):
         self.base_branch_names = base_branch_names
         self.from_time = from_time
         self.to_time = to_time
+        self.tracking_id = tracking_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "diff_branch_names": self.diff_branch_names,
             "base_branch_names": self.base_branch_names,
             "from_time": self.from_time.to_string() if self.from_time else None,
             "to_time": self.to_time.to_string() if self.to_time else None,
+            "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,
         }
 
         query = """
         MATCH (diff_root:DiffRoot)
-        WHERE ($diff_branch_names IS NULL OR diff_root.diff_branch IN $diff_branch_names)
+        WHERE (diff_root.is_merged IS NULL OR diff_root.is_merged <> TRUE)
+        AND ($diff_branch_names IS NULL OR diff_root.diff_branch IN $diff_branch_names)
         AND ($base_branch_names IS NULL OR diff_root.base_branch IN $base_branch_names)
         AND ($from_time IS NULL OR diff_root.from_time >= $from_time)
         AND ($to_time IS NULL OR diff_root.to_time <= $to_time)
+        AND ($tracking_id IS NULL OR diff_root.tracking_id = $tracking_id)
         """
         self.return_labels = ["diff_root"]
         self.add_to_query(query=query)