infrahub-server 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

infrahub/core/diff/calculator.py

@@ -181,8 +181,11 @@ class DiffCalculator:
         log.info("Diff property-level calculation queries for branch complete")
 
         if base_branch.name != diff_branch.name:
-            current_node_field_specifiers = diff_parser.get_current_node_field_specifiers()
             new_node_field_specifiers = diff_parser.get_new_node_field_specifiers()
+            current_node_field_specifiers = None
+            if previous_node_specifiers is not None:
+                current_node_field_specifiers = previous_node_specifiers - new_node_field_specifiers
+
             base_calculation_request = DiffCalculationRequest(
                 base_branch=base_branch,
                 diff_branch=base_branch,

infrahub/core/diff/query_parser.py

@@ -486,6 +486,7 @@ class DiffQueryParser:
         self._previous_node_field_specifiers = previous_node_field_specifiers or NodeFieldSpecifierMap()
         self._new_node_field_specifiers: NodeFieldSpecifierMap | None = None
         self._current_node_field_specifiers: NodeFieldSpecifierMap | None = None
+        self._diff_node_field_specifiers: NodeFieldSpecifierMap = NodeFieldSpecifierMap()
 
     def get_branches(self) -> set[str]:
         return set(self._final_diff_root_by_branch.keys())
@@ -497,33 +498,17 @@ class DiffQueryParser:
             return self._final_diff_root_by_branch[branch]
         return DiffRoot(from_time=self.from_time, to_time=self.to_time, uuid=str(uuid4()), branch=branch, nodes=[])
 
-    def get_diff_node_field_specifiers(self) -> NodeFieldSpecifierMap:
-        node_field_specifiers_map = NodeFieldSpecifierMap()
-        if self.diff_branch_name not in self._diff_root_by_branch:
-            return node_field_specifiers_map
-        diff_root = self._diff_root_by_branch[self.diff_branch_name]
-        for node in diff_root.nodes_by_identifier.values():
-            for attribute_name in node.attributes_by_name:
-                node_field_specifiers_map.add_entry(node_uuid=node.uuid, kind=node.kind, field_name=attribute_name)
-            for relationship_diff in node.relationships_by_identifier.values():
-                node_field_specifiers_map.add_entry(
-                    node_uuid=node.uuid, kind=node.kind, field_name=relationship_diff.identifier
-                )
-        return node_field_specifiers_map
-
     def get_new_node_field_specifiers(self) -> NodeFieldSpecifierMap:
-        if self._new_node_field_specifiers is not None:
-            return self._new_node_field_specifiers
-        branch_node_specifiers = self.get_diff_node_field_specifiers()
-        self._new_node_field_specifiers = branch_node_specifiers - self._previous_node_field_specifiers
-        return self._new_node_field_specifiers
-
-    def get_current_node_field_specifiers(self) -> NodeFieldSpecifierMap:
-        if self._current_node_field_specifiers is not None:
-            return self._current_node_field_specifiers
-        new_node_field_specifiers = self.get_new_node_field_specifiers()
-        self._current_node_field_specifiers = self._previous_node_field_specifiers - new_node_field_specifiers
-        return self._current_node_field_specifiers
+        return self._diff_node_field_specifiers - self._previous_node_field_specifiers
+
+    def is_new_node_field_specifier(self, node_uuid: str, kind: str, field_name: str) -> bool:
+        if not self._diff_node_field_specifiers.has_entry(node_uuid=node_uuid, kind=kind, field_name=field_name):
+            return False
+        if self._previous_node_field_specifiers and self._previous_node_field_specifiers.has_entry(
+            node_uuid=node_uuid, kind=kind, field_name=field_name
+        ):
+            return False
+        return True
 
     def read_result(self, query_result: QueryResult) -> None:
         try:
@@ -533,8 +518,6 @@ class DiffQueryParser:
             return
         database_path = DatabasePath.from_cypher_path(cypher_path=path)
         self._parse_path(database_path=database_path)
-        self._current_node_field_specifiers = None
-        self._new_node_field_specifiers = None
 
     def parse(self, include_unchanged: bool = False) -> None:
         self._new_node_field_specifiers = None
@@ -617,11 +600,15 @@ class DiffQueryParser:
         branch_name = database_path.deepest_branch
         from_time = self.from_time
         if branch_name == self.base_branch_name:
-            new_node_field_specifiers = self.get_new_node_field_specifiers()
-            if new_node_field_specifiers.has_entry(
+            if self.is_new_node_field_specifier(
                 node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=attribute_name
             ):
                 from_time = self.diff_branched_from_time
+        else:
+            # Add to diff node field specifiers if this is the diff branch
+            self._diff_node_field_specifiers.add_entry(
+                node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=attribute_name
+            )
         if attribute_name not in diff_node.attributes_by_name:
             diff_node.attributes_by_name[attribute_name] = DiffAttributeIntermediate(
                 uuid=database_path.attribute_id,
@@ -663,11 +650,15 @@ class DiffQueryParser:
             branch_name = database_path.deepest_branch
             from_time = self.from_time
             if branch_name == self.base_branch_name:
-                new_node_field_specifiers = self.get_new_node_field_specifiers()
-                if new_node_field_specifiers.has_entry(
+                if self.is_new_node_field_specifier(
                     node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=relationship_schema.get_identifier()
                 ):
                     from_time = self.diff_branched_from_time
+            else:
+                # Add to diff node field specifiers if this is the diff branch
+                self._diff_node_field_specifiers.add_entry(
+                    node_uuid=diff_node.uuid, kind=diff_node.kind, field_name=relationship_schema.get_identifier()
+                )
             diff_relationship = DiffRelationshipIntermediate(
                 name=relationship_schema.name,
                 cardinality=relationship_schema.cardinality,

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -1,26 +1,19 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from infrahub.core import registry
 from infrahub.core.constants import NULL_VALUE
-from infrahub.core.schema import (
-    MainSchemaTypes,
-    SchemaAttributePath,
-    SchemaAttributePathValue,
-)
 from infrahub.core.schema.basenode_schema import (
-    SchemaUniquenessConstraintPath,
     UniquenessConstraintType,
     UniquenessConstraintViolation,
 )
-from infrahub.core.validators.uniqueness.index import UniquenessQueryResultsIndex
 from infrahub.core.validators.uniqueness.model import (
-    NodeUniquenessQueryRequest,
-    QueryAttributePath,
-    QueryRelationshipAttributePath,
+    NodeUniquenessQueryRequestValued,
+    QueryAttributePathValued,
+    QueryRelationshipPathValued,
 )
-from infrahub.core.validators.uniqueness.query import NodeUniqueAttributeConstraintQuery
+from infrahub.core.validators.uniqueness.query import UniquenessValidationQuery
 from infrahub.exceptions import HFIDViolatedError, ValidationError
 
 from .interface import NodeConstraintInterface
@@ -28,8 +21,11 @@ from .interface import NodeConstraintInterface
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.node import Node
-    from infrahub.core.query import QueryResult
     from infrahub.core.relationship.model import RelationshipManager
+    from infrahub.core.schema import (
+        MainSchemaTypes,
+        SchemaAttributePath,
+    )
     from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
@@ -40,72 +36,38 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name)
 
-    async def _build_query_request(
-        self,
-        updated_node: Node,
-        node_schema: MainSchemaTypes,
-        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
-        filters: list[str] | None = None,
-    ) -> NodeUniquenessQueryRequest:
-        query_request = NodeUniquenessQueryRequest(kind=node_schema.kind)
-        for uniqueness_constraint_path in uniqueness_constraint_paths:
-            include_in_query = not filters
-            query_relationship_paths: set[QueryRelationshipAttributePath] = set()
-            query_attribute_paths: set[QueryAttributePath] = set()
-            for attribute_path in uniqueness_constraint_path.attributes_paths:
-                if attribute_path.related_schema and attribute_path.relationship_schema:
-                    if filters and attribute_path.relationship_schema.name in filters:
-                        include_in_query = True
-
-                    relationship_manager: RelationshipManager = getattr(
-                        updated_node, attribute_path.relationship_schema.name
-                    )
-                    related_node = await relationship_manager.get_peer(db=self.db)
-                    related_node_id = related_node.get_id() if related_node else None
-                    query_relationship_paths.add(
-                        QueryRelationshipAttributePath(
-                            identifier=attribute_path.relationship_schema.get_identifier(),
-                            value=related_node_id,
-                        )
-                    )
-                    continue
-                if attribute_path.attribute_schema:
-                    if filters and attribute_path.attribute_schema.name in filters:
-                        include_in_query = True
-                    attribute_name = attribute_path.attribute_schema.name
-                    attribute = getattr(updated_node, attribute_name)
-                    if attribute.is_enum and attribute.value:
-                        attribute_value = attribute.value.value
-                    else:
-                        attribute_value = attribute.value
-                    if attribute_value is None:
-                        attribute_value = NULL_VALUE
-                    query_attribute_paths.add(
-                        QueryAttributePath(
-                            attribute_name=attribute_name,
-                            property_name=attribute_path.attribute_property_name or "value",
-                            value=attribute_value,
-                        )
-                    )
-            if include_in_query:
-                query_request.relationship_attribute_paths |= query_relationship_paths
-                query_request.unique_attribute_paths |= query_attribute_paths
-        return query_request
-
-    async def _get_node_attribute_path_values(
+    async def _get_unique_valued_paths(
         self,
         updated_node: Node,
         path_group: list[SchemaAttributePath],
-    ) -> list[SchemaAttributePathValue]:
-        node_value_combination = []
+        filters: list[str],
+    ) -> list[QueryAttributePathValued | QueryRelationshipPathValued]:
+        # if filters are provided, we need to check if the path group is relevant to the filters
+        if filters:
+            field_names: list[str] = []
+            for schema_attribute_path in path_group:
+                if schema_attribute_path.relationship_schema:
+                    field_names.append(schema_attribute_path.relationship_schema.name)
+                elif schema_attribute_path.attribute_schema:
+                    field_names.append(schema_attribute_path.attribute_schema.name)
+
+            if not set(field_names) & set(filters):
+                return []
+
+        valued_paths: list[QueryAttributePathValued | QueryRelationshipPathValued] = []
         for schema_attribute_path in path_group:
             if schema_attribute_path.relationship_schema:
                 relationship_name = schema_attribute_path.relationship_schema.name
                 relationship_manager: RelationshipManager = getattr(updated_node, relationship_name)
                 related_node = await relationship_manager.get_peer(db=self.db)
                 related_node_id = related_node.get_id() if related_node else None
-                node_value_combination.append(
-                    SchemaAttributePathValue.from_schema_attribute_path(schema_attribute_path, value=related_node_id)
+                valued_paths.append(
+                    QueryRelationshipPathValued(
+                        relationship_schema=schema_attribute_path.relationship_schema,
+                        peer_id=related_node_id,
+                        attribute_name=None,
+                        attribute_value=None,
+                    )
                 )
             elif schema_attribute_path.attribute_schema:
                 attribute_name = schema_attribute_path.attribute_schema.name
@@ -115,86 +77,79 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                     attribute_value = attribute_value.value
                 elif attribute_value is None:
                     attribute_value = NULL_VALUE
-                node_value_combination.append(
-                    SchemaAttributePathValue.from_schema_attribute_path(
-                        schema_attribute_path,
+                valued_paths.append(
+                    QueryAttributePathValued(
+                        attribute_name=attribute_name,
                         value=attribute_value,
                     )
                 )
-        return node_value_combination
+        return valued_paths
 
-    async def _get_violations(
+    async def _get_single_schema_violations(
         self,
-        updated_node: Node,
-        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
-        query_results: Iterable[QueryResult],
+        node: Node,
+        node_schema: MainSchemaTypes,
+        filters: list[str],
+        at: Timestamp | None = None,
     ) -> list[UniquenessConstraintViolation]:
-        results_index = UniquenessQueryResultsIndex(
-            query_results=query_results, exclude_node_ids={updated_node.get_id()}
+        schema_branch = self.db.schema.get_schema_branch(name=self.branch.name)
+
+        uniqueness_constraint_paths = node_schema.get_unique_constraint_schema_attribute_paths(
+            schema_branch=schema_branch
         )
-        violations = []
+
+        violations: list[UniquenessConstraintViolation] = []
         for uniqueness_constraint_path in uniqueness_constraint_paths:
-            # path_group = one constraint (that can contain multiple items)
-            schema_attribute_path_values = await self._get_node_attribute_path_values(
-                updated_node=updated_node, path_group=uniqueness_constraint_path.attributes_paths
+            valued_paths = await self._get_unique_valued_paths(
+                updated_node=node,
+                path_group=uniqueness_constraint_path.attributes_paths,
+                filters=filters,
             )
 
-            # constraint cannot be violated if this node is missing any values
-            if any(sapv.value is None for sapv in schema_attribute_path_values):
+            if not valued_paths:
                 continue
 
-            matching_node_ids = results_index.get_node_ids_for_value_group(schema_attribute_path_values)
-            if not matching_node_ids:
+            # Create the valued query request for this constraint
+            valued_query_request = NodeUniquenessQueryRequestValued(
+                kind=node_schema.kind,
+                unique_valued_paths=valued_paths,
+            )
+
+            # Execute the query
+            query = await UniquenessValidationQuery.init(
+                db=self.db,
+                branch=self.branch,
+                at=at,
+                query_request=valued_query_request,
+                node_ids_to_exclude=[node.get_id()],
+            )
+            await query.execute(db=self.db)
+
+            # Get violation nodes from the query results
+            violation_nodes = query.get_violation_nodes()
+            if not violation_nodes:
                 continue
 
+            # Create violation object
             uniqueness_constraint_fields = []
-            for sapv in schema_attribute_path_values:
-                if sapv.relationship_schema:
-                    uniqueness_constraint_fields.append(sapv.relationship_schema.name)
-                elif sapv.attribute_schema:
-                    uniqueness_constraint_fields.append(sapv.attribute_schema.name)
-
-            violations.append(
-                UniquenessConstraintViolation(
-                    nodes_ids=matching_node_ids,
-                    fields=uniqueness_constraint_fields,
-                    typ=uniqueness_constraint_path.typ,
+            for valued_path in valued_paths:
+                if isinstance(valued_path, QueryRelationshipPathValued):
+                    uniqueness_constraint_fields.append(valued_path.relationship_schema.name)
+                elif isinstance(valued_path, QueryAttributePathValued):
+                    uniqueness_constraint_fields.append(valued_path.attribute_name)
+
+            matching_node_ids = {node_id for node_id, _ in violation_nodes}
+            if matching_node_ids:
+                violations.append(
+                    UniquenessConstraintViolation(
+                        nodes_ids=matching_node_ids,
+                        fields=uniqueness_constraint_fields,
+                        typ=uniqueness_constraint_path.typ,
+                    )
                 )
-            )
 
         return violations
 
-    async def _get_single_schema_violations(
-        self,
-        node: Node,
-        node_schema: MainSchemaTypes,
-        at: Timestamp | None = None,
-        filters: list[str] | None = None,
-    ) -> list[UniquenessConstraintViolation]:
-        schema_branch = self.db.schema.get_schema_branch(name=self.branch.name)
-
-        uniqueness_constraint_paths = node_schema.get_unique_constraint_schema_attribute_paths(
-            schema_branch=schema_branch
-        )
-        query_request = await self._build_query_request(
-            updated_node=node,
-            node_schema=node_schema,
-            uniqueness_constraint_paths=uniqueness_constraint_paths,
-            filters=filters,
-        )
-        if not query_request:
-            return []
-
-        query = await NodeUniqueAttributeConstraintQuery.init(
-            db=self.db, branch=self.branch, at=at, query_request=query_request, min_count_required=0
-        )
-        await query.execute(db=self.db)
-        return await self._get_violations(
-            updated_node=node,
-            uniqueness_constraint_paths=uniqueness_constraint_paths,
-            query_results=query.get_results(),
-        )
-
     async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None:
         def _frozen_constraints(schema: MainSchemaTypes) -> frozenset[frozenset[str]]:
             if not schema.uniqueness_constraints:
@@ -218,7 +173,8 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
         if include_node_schema:
             schemas_to_check.append(node_schema)
 
-        violations = []
+        violations: list[UniquenessConstraintViolation] = []
+
         for schema in schemas_to_check:
             schema_filters = list(filters) if filters is not None else []
             for attr_schema in schema.attributes:

infrahub/core/validators/uniqueness/model.py

@@ -59,6 +59,23 @@ class NodeUniquenessQueryRequest(BaseModel):
         )
 
 
+class QueryRelationshipPathValued(BaseModel):
+    relationship_schema: RelationshipSchema
+    peer_id: str | None
+    attribute_name: str | None
+    attribute_value: str | bool | int | float | None
+
+
+class QueryAttributePathValued(BaseModel):
+    attribute_name: str
+    value: str | bool | int | float
+
+
+class NodeUniquenessQueryRequestValued(BaseModel):
+    kind: str
+    unique_valued_paths: list[QueryAttributePathValued | QueryRelationshipPathValued]
+
+
 class NonUniqueRelatedAttribute(BaseModel):
     relationship: RelationshipSchema
     attribute_name: str

infrahub/core/validators/uniqueness/query.py

@@ -5,10 +5,12 @@ from typing import TYPE_CHECKING, Any
 from infrahub.core.constants.relationship_label import RELATIONSHIP_TO_VALUE_LABEL
 from infrahub.core.query import Query, QueryType
 
+from .model import QueryAttributePathValued, QueryRelationshipPathValued
+
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
-    from .model import NodeUniquenessQueryRequest
+    from .model import NodeUniquenessQueryRequest, NodeUniquenessQueryRequestValued
 
 
 class NodeUniqueAttributeConstraintQuery(Query):
@@ -244,3 +246,212 @@ class NodeUniqueAttributeConstraintQuery(Query):
             "attr_value",
             "relationship_identifier",
         ]
+
+
+class UniquenessValidationQuery(Query):
+    name = "uniqueness_constraint_validation"
+    type = QueryType.READ
+
+    def __init__(
+        self,
+        query_request: NodeUniquenessQueryRequestValued,
+        node_ids_to_exclude: list[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        self.query_request = query_request
+        self.node_ids_to_exclude = node_ids_to_exclude
+        super().__init__(**kwargs)
+
+    def _build_attr_subquery(
+        self, node_kind: str, attr_path: QueryAttributePathValued, index: int, branch_filter: str, is_first_query: bool
+    ) -> tuple[str, dict[str, str | int | float | bool]]:
+        attr_name_var = f"attr_name_{index}"
+        attr_value_var = f"attr_value_{index}"
+        if is_first_query:
+            first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
+        else:
+            first_query_filter = ""
+        attribute_query = """
+MATCH (node:%(node_kind)s)-[:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+%(first_query_filter)s
+WITH DISTINCT node
+CALL (node) {
+    MATCH (node)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
+    WHERE %(branch_filter)s
+    WITH attr, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH attr, is_active
+    LIMIT 1
+    WITH attr, is_active
+    WHERE is_active = TRUE
+    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    WHERE %(branch_filter)s
+    WITH r
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    WITH r
+    WHERE r.status = "active"
+    RETURN 1 AS is_match_%(index)s
+}
+        """ % {
+            "first_query_filter": first_query_filter,
+            "node_kind": node_kind,
+            "attr_name_var": attr_name_var,
+            "attr_value_var": attr_value_var,
+            "branch_filter": branch_filter,
+            "index": index,
+        }
+        params: dict[str, str | int | float | bool] = {
+            attr_name_var: attr_path.attribute_name,
+            attr_value_var: attr_path.value,
+        }
+        return attribute_query, params
+
+    def _build_rel_subquery(
+        self,
+        node_kind: str,
+        rel_path: QueryRelationshipPathValued,
+        index: int,
+        branch_filter: str,
+        is_first_query: bool,
+    ) -> tuple[str, dict[str, str | int | float | bool]]:
+        params: dict[str, str | int | float | bool] = {}
+        rel_attr_query = ""
+        rel_attr_match = ""
+        if rel_path.attribute_name and rel_path.attribute_value:
+            attr_name_var = f"attr_name_{index}"
+            attr_value_var = f"attr_value_{index}"
+            rel_attr_query = """
+    MATCH (peer)-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})
+    WHERE %(branch_filter)s
+    WITH attr, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH attr, is_active
+    LIMIT 1
+    WITH attr, is_active
+    WHERE is_active = TRUE
+    MATCH (attr)-[r:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})
+    WHERE %(branch_filter)s
+    WITH r
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    WITH r
+    WHERE r.status = "active"
+            """ % {"attr_name_var": attr_name_var, "attr_value_var": attr_value_var, "branch_filter": branch_filter}
+            rel_attr_match = (
+                "-[r:HAS_ATTRIBUTE]->(attr:Attribute {name: $%(attr_name_var)s})-[:HAS_VALUE]->(:AttributeValue {value: $%(attr_value_var)s})"
+                % {
+                    "attr_name_var": attr_name_var,
+                    "attr_value_var": attr_value_var,
+                }
+            )
+            params[attr_name_var] = rel_path.attribute_name
+            params[attr_value_var] = rel_path.attribute_value
+        query_arrows = rel_path.relationship_schema.get_query_arrows()
+        rel_name_var = f"rel_name_{index}"
+        # long path MATCH is required to hit an index on the peer or AttributeValue of the peer
+        first_match = (
+            "MATCH (node:%(node_kind)s)%(lstart)s[:IS_RELATED]%(lend)s(:Relationship {name: $%(rel_name_var)s})%(rstart)s[:IS_RELATED]%(rend)s"
+            % {
+                "node_kind": node_kind,
+                "lstart": query_arrows.left.start,
+                "lend": query_arrows.left.end,
+                "rstart": query_arrows.right.start,
+                "rend": query_arrows.right.end,
+                "rel_name_var": rel_name_var,
+            }
+        )
+        peer_where = f"WHERE {branch_filter}"
+        if rel_path.peer_id:
+            peer_id_var = f"peer_id_{index}"
+            peer_where += f" AND peer.uuid = ${peer_id_var}"
+            params[peer_id_var] = rel_path.peer_id
+            first_match += "(:Node {uuid: $%(peer_id_var)s})" % {"peer_id_var": peer_id_var}
+        else:
+            peer_where += " AND peer.uuid <> node.uuid"
+            first_match += "(:Node)"
+        if rel_attr_match:
+            first_match += rel_attr_match
+        if is_first_query:
+            first_query_filter = "WHERE $node_ids_to_exclude IS NULL OR NOT node.uuid IN $node_ids_to_exclude"
+        else:
+            first_query_filter = ""
+        relationship_query = f"""
+{first_match}
+{first_query_filter}
+WITH DISTINCT node
+        """
+        relationship_query += """
+CALL (node) {
+    MATCH (node)%(lstart)s[r:IS_RELATED]%(lend)s(rel:Relationship {name: $%(rel_name_var)s})
+    WHERE %(branch_filter)s
+    WITH rel, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH rel, is_active
+    LIMIT 1
+    WITH rel, is_active
+    WHERE is_active = TRUE
+    MATCH (rel)%(rstart)s[r:IS_RELATED]%(rend)s(peer:Node)
+    %(peer_where)s
+    WITH peer, r.status = "active" AS is_active
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    WITH peer, is_active
+    LIMIT 1
+    WITH peer, is_active
+    WHERE is_active = TRUE
+%(rel_attr_query)s
+    RETURN 1 AS is_match_%(index)s
+    LIMIT 1
+}
+        """ % {
+            "rel_name_var": rel_name_var,
+            "lstart": query_arrows.left.start,
+            "lend": query_arrows.left.end,
+            "rstart": query_arrows.right.start,
+            "rend": query_arrows.right.end,
+            "peer_where": peer_where,
+            "rel_attr_query": rel_attr_query,
+            "branch_filter": branch_filter,
+            "index": index,
+        }
+        params[rel_name_var] = rel_path.relationship_schema.get_identifier()
+        return relationship_query, params
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
+        self.params["node_ids_to_exclude"] = self.node_ids_to_exclude
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string(), is_isolated=False)
+        self.params.update(branch_params)
+
+        subqueries = []
+        for index, schema_path in enumerate(self.query_request.unique_valued_paths):
+            is_first_query = index == 0
+            if isinstance(schema_path, QueryAttributePathValued):
+                subquery, params = self._build_attr_subquery(
+                    node_kind=self.query_request.kind,
+                    attr_path=schema_path,
+                    index=index,
+                    branch_filter=branch_filter,
+                    is_first_query=is_first_query,
+                )
+            else:
+                subquery, params = self._build_rel_subquery(
+                    node_kind=self.query_request.kind,
+                    rel_path=schema_path,
+                    index=index,
+                    branch_filter=branch_filter,
+                    is_first_query=is_first_query,
+                )
+            subqueries.append(subquery)
+            self.params.update(params)
+
+        full_query = "\n".join(subqueries)
+        self.add_to_query(full_query)
+        self.return_labels = ["node.uuid AS node_uuid", "node.kind AS node_kind"]
+
+    def get_violation_nodes(self) -> list[tuple[str, str]]:
+        violation_tuples = []
+        for result in self.results:
+            violation_tuples.append(
+                (result.get_as_type("node_uuid", return_type=str), result.get_as_type("node_kind", return_type=str))
+            )
+        return violation_tuples

infrahub/graphql/mutations/main.py

@@ -25,7 +25,7 @@ from infrahub.core.timestamp import Timestamp
 from infrahub.database import retry_db_transaction
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.events.generator import generate_node_mutation_events
-from infrahub.exceptions import HFIDViolatedError, InitializationError
+from infrahub.exceptions import HFIDViolatedError, InitializationError, NodeNotFoundError
 from infrahub.graphql.context import apply_external_context
 from infrahub.lock import InfrahubMultiLock, build_object_lock_name
 from infrahub.log import get_log_data, get_logger
@@ -384,7 +384,23 @@ class InfrahubMutationMixin:
             if len(exc.matching_nodes_ids) > 1:
                 raise RuntimeError(f"Multiple {schema_name} nodes have the same hfid") from exc
             node_id = list(exc.matching_nodes_ids)[0]
-            node = await NodeManager.get_one(db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True)
+
+            try:
+                node = await NodeManager.get_one(
+                    db=db, id=node_id, kind=schema_name, branch=branch, raise_on_error=True
+                )
+            except NodeNotFoundError as exc:
+                if branch.is_default:
+                    raise
+                raise NodeNotFoundError(
+                    node_type=exc.node_type,
+                    identifier=exc.identifier,
+                    branch_name=branch.name,
+                    message=(
+                        f"Node {exc.identifier} / {exc.node_type} uses this human-friendly ID, but does not exist on"
+                        f" this branch. Please rebase this branch to access {exc.identifier} / {exc.node_type}"
+                    ),
+                ) from exc
             updated_obj, mutation = await cls._call_mutate_update(
                 info=info,
                 data=data,

infrahub_sdk/node/node.py

@@ -507,11 +507,17 @@ class InfrahubNode(InfrahubNodeBase):
 
             if rel_schema.cardinality == "one":
                 if isinstance(rel_data, RelatedNode):
-                    peer_id_data: dict[str, Any] = {}
-                    if rel_data.id:
-                        peer_id_data["id"] = rel_data.id
-                    if rel_data.hfid:
-                        peer_id_data["hfid"] = rel_data.hfid
+                    peer_id_data: dict[str, Any] = {
+                        key: value
+                        for key, value in (
+                            ("id", rel_data.id),
+                            ("hfid", rel_data.hfid),
+                            ("__typename", rel_data.typename),
+                            ("kind", rel_data.kind),
+                            ("display_label", rel_data.display_label),
+                        )
+                        if value is not None
+                    }
                     if peer_id_data:
                         rel_data = peer_id_data
                     else:
@@ -1090,11 +1096,17 @@ class InfrahubNodeSync(InfrahubNodeBase):
 
             if rel_schema.cardinality == "one":
                 if isinstance(rel_data, RelatedNodeSync):
-                    peer_id_data: dict[str, Any] = {}
-                    if rel_data.id:
-                        peer_id_data["id"] = rel_data.id
-                    if rel_data.hfid:
-                        peer_id_data["hfid"] = rel_data.hfid
+                    peer_id_data: dict[str, Any] = {
+                        key: value
+                        for key, value in (
+                            ("id", rel_data.id),
+                            ("hfid", rel_data.hfid),
+                            ("__typename", rel_data.typename),
+                            ("kind", rel_data.kind),
+                            ("display_label", rel_data.display_label),
+                        )
+                        if value is not None
+                    }
                     if peer_id_data:
                         rel_data = peer_id_data
                     else:

infrahub_sdk/node/related_node.py

@@ -39,6 +39,7 @@ class RelatedNodeBase:
         self._hfid: list[str] | None = None
         self._display_label: str | None = None
         self._typename: str | None = None
+        self._kind: str | None = None
 
         if isinstance(data, (CoreNodeBase)):
             self._peer = data
@@ -118,6 +119,12 @@ class RelatedNodeBase:
             return self._peer.typename
         return self._typename
 
+    @property
+    def kind(self) -> str | None:
+        if self._peer:
+            return self._peer.get_kind()
+        return self._kind
+
     def _generate_input_data(self, allocate_from_pool: bool = False) -> dict[str, Any]:
         data: dict[str, Any] = {}
 

{infrahub_server-1.3.1.dist-info → infrahub_server-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: infrahub-server
-Version: 1.3.1
+Version: 1.3.2
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 License: AGPL-3.0-only
 Author: OpsMill

{infrahub_server-1.3.1.dist-info → infrahub_server-1.3.2.dist-info}/RECORD

@@ -80,7 +80,7 @@ infrahub/core/diff/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 infrahub/core/diff/artifacts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/core/diff/artifacts/calculator.py,sha256=qk1DspB3bkKeWJFesLbmziCALVnbRadjrez1kn_IZWU,4435
 infrahub/core/diff/branch_differ.py,sha256=62TRs3tGb4brQqCaVoI2iMIiPnny3_0_e9j-Mq-AXx4,7752
-infrahub/core/diff/calculator.py,sha256=Wn0IRqCujwfXXNQbi6n-npEE0UrcWi5qq58wAIBMZsM,9976
+infrahub/core/diff/calculator.py,sha256=1ure9OGmoopCLMyjIK4r6zmLJ4eAswEI7yB0WgOkgx0,10088
 infrahub/core/diff/combiner.py,sha256=qL4WQsphB2sVnncgskSG_QcJBqBHjaK0vWU_apeTn-E,23508
 infrahub/core/diff/conflict_transferer.py,sha256=LZCuS9Dbr4yBf-bd3RF-9cPnaOvVWiU3KBmmwxbRZl0,3968
 infrahub/core/diff/conflicts_enricher.py,sha256=x6qiZOXO2A3BQ2Fm78apJ4WA7HLzPO84JomJfcyuyDg,12552
@@ -127,7 +127,7 @@ infrahub/core/diff/query/save.py,sha256=xBKWpWfRWfaP7g523xKMK82ogg0AfVQTTMeyz8oe
 infrahub/core/diff/query/summary_counts_enricher.py,sha256=HuMeQfa2Ce0qFmGTSfUV-LncauEsBDhdDcs1QpZOETA,9957
 infrahub/core/diff/query/time_range_query.py,sha256=Xv9_Y_UJ45UsqfxosoAxXMY47-EpO6fHNIqdwFpysBQ,2976
 infrahub/core/diff/query/update_conflict_query.py,sha256=kQkFazz88wnApr8UU_qb0ruzhmrhWiqhbErukSAMhLA,1212
-infrahub/core/diff/query_parser.py,sha256=6OWI_ynplysO6VH1vCfqiV_VmXvAfoa-bIRJ7heVTjY,37217
+infrahub/core/diff/query_parser.py,sha256=-uz4Fd2briFx7447UGii4RBSJjP_LnV0WiEBOjh_chc,36536
 infrahub/core/diff/repository/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/core/diff/repository/deserializer.py,sha256=bhN9ao8HxqKyRz273QGLNV9z9_SS4EQnM9JoY5ptx78,21337
 infrahub/core/diff/repository/repository.py,sha256=x3QP9VmBVYBOVtf3IZUyzXqCd8sSfmHTqVoYlAOdGao,26006
@@ -206,7 +206,7 @@ infrahub/core/node/__init__.py,sha256=4of1tA26-EV8FOubg-rhBFU9wkJ0BBipePnnvx1vi_
 infrahub/core/node/base.py,sha256=BAowVRCK_WC50yXym1kCyUppJDJnrODGU5uoj1s0Yd4,2564
 infrahub/core/node/constraints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/core/node/constraints/attribute_uniqueness.py,sha256=9MThTmuqZ7RgK71ZZARlw1k1x3ARn1U67g2_Gatd6rE,2099
-infrahub/core/node/constraints/grouped_uniqueness.py,sha256=GQ1-l4ZoZR6FoklHAdqCaNwX3TmW6qrvKYJEVtdPOfc,12056
+infrahub/core/node/constraints/grouped_uniqueness.py,sha256=F5pmnXVuQNlVmdZY5FRxSGK4gGi1BK1IRgw4emCTlLw,9506
 infrahub/core/node/constraints/interface.py,sha256=fwB32pRLxteQyKRArqekQ0RXlrDkyzp7Vmq03vSpUEo,291
 infrahub/core/node/create.py,sha256=1mAFaMLqRmuONIwL549JQLFbOpEbP3rBQEb1D2VArcc,7752
 infrahub/core/node/delete_validator.py,sha256=mj_HQXkTeP_A3po65-R5bCJnDM9CmFFmcUQIxwPlofc,10559
@@ -334,8 +334,8 @@ infrahub/core/validators/tasks.py,sha256=oaV1rOFiGOkbZYjpK2d5UTj_LFJAghSMKbO7w5f
 infrahub/core/validators/uniqueness/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 infrahub/core/validators/uniqueness/checker.py,sha256=RpiLpIjbdkwwjivry-vjEkVim6ZoC-t2H5Bal7ngASQ,10375
 infrahub/core/validators/uniqueness/index.py,sha256=Jw1o-UVinQquNduZ5vCCzt8GUfIEdVzBo-1XyRti8F8,5068
-infrahub/core/validators/uniqueness/model.py,sha256=V2aejcuHPhgC5nTrS7xX0JFMzprVu90QAau-rUzruCY,5135
-infrahub/core/validators/uniqueness/query.py,sha256=5HRjt4WlQCIP9krlKqkBNMJGgavKik8-Z11Q1_YllLk,11650
+infrahub/core/validators/uniqueness/model.py,sha256=3MXrE9lLMI1B2TXxMS2Eb59uOI_Q4havuluoI8fy4EE,5593
+infrahub/core/validators/uniqueness/query.py,sha256=3qJfoxwau3303BCkjJwPngotQYjTRuewqTQvcPzsICE,20103
 infrahub/database/__init__.py,sha256=sRME_Cm74b5MsKyqMLRpAv3E38Vw2H1yv20JjSBb-Vg,20836
 infrahub/database/index.py,sha256=ATLqw9Grqbq7haGGm14VSEPmcPniid--YATiffo4sA0,1676
 infrahub/database/memgraph.py,sha256=Fg3xHP9s0MiBBmMvcEmsJvuIUSq8U_XCS362HDE9d1s,1742
@@ -471,7 +471,7 @@ infrahub/graphql/mutations/diff_conflict.py,sha256=JngQfyKXCVlmtlqQ_VyabmrOEDOEK
 infrahub/graphql/mutations/generator.py,sha256=Ulw4whZm8Gc8lJjwfUFoFSsR0cOUliFKl87Oca4B9O0,3579
 infrahub/graphql/mutations/graphql_query.py,sha256=mp_O2byChneCihUrEAFEiIAgJ1gW9WrgtwPetUQmkJw,3562
 infrahub/graphql/mutations/ipam.py,sha256=wIN8OcTNCHVy32YgatWZi2Of-snFYBd4wlxOAJvE-AY,15961
-infrahub/graphql/mutations/main.py,sha256=I4qE7mf-vQcDqPdW_8MsyRe_GtuPeHJj-pjB3_tzsPk,19716
+infrahub/graphql/mutations/main.py,sha256=GgETTp-KKyVTnvD8GO7hp1oWIq-eOJ7E_WL-wXUP5Us,20392
 infrahub/graphql/mutations/menu.py,sha256=u2UbOA-TFDRcZRGFkgYTmpGxN2IAUgOvJXd7SnsufyI,3708
 infrahub/graphql/mutations/models.py,sha256=ilkSLr8OxVO9v3Ra_uDyUTJT9qPOmdPMqQbuWIydJMo,264
 infrahub/graphql/mutations/node_getter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -719,10 +719,10 @@ infrahub_sdk/jinja2.py,sha256=lTfV9E_P5gApaX6RW9M8U8oixQi-0H3U8wcs8fdGVaU,1150
 infrahub_sdk/node/__init__.py,sha256=clAUZ9lNVPFguelR5Sg9PzklAZruTKEm2xk-BaO68l8,1262
 infrahub_sdk/node/attribute.py,sha256=oEY1qxip8ETEx9Q33NhSQo013zmzrmpVIFzSkEMUY8M,4547
 infrahub_sdk/node/constants.py,sha256=TJO4uxvv7sc3FjoLdQdV7Ccymqz8AqxDenARst8awb4,775
-infrahub_sdk/node/node.py,sha256=ht6T2Td9CSRrdgCTIemVJmTqEuL4a9YC77zhElN8S0U,70138
+infrahub_sdk/node/node.py,sha256=34rIDO7ZdA8uJpsuBbPDDZ5GSUKkL1nlnFBvoM5bDRo,70674
 infrahub_sdk/node/parsers.py,sha256=sLDdT6neoYSZIjOCmq8Bgd0LK8FFoasjvJLuSz0whSU,543
 infrahub_sdk/node/property.py,sha256=8Mjkc8bp3kLlHyllwxDJlpJTuOA1ciMgY8mtH3dFVLM,728
-infrahub_sdk/node/related_node.py,sha256=41VTj4k1qojuyBZr0XiD7e2NESl8YwsU3fCmaarlrD0,9916
+infrahub_sdk/node/related_node.py,sha256=fPMnZ83OZnnbimaPC14MdE3lR-kumAA6hbOhRlo1gms,10093
 infrahub_sdk/node/relationship.py,sha256=ax9BfYFEfzvUmVxiC1RrhtnpV9ZPuuvQFN_DNRGUHLU,11911
 infrahub_sdk/object_store.py,sha256=d-EDnxPpw_7BsbjbGbH50rjt-1-Ojj2zNrhFansP5hA,4299
 infrahub_sdk/operation.py,sha256=hsbZSjLbLsqvjZg5R5x_bOxxlteXJAk0fQy3mLrZhn4,2730
@@ -801,8 +801,8 @@ infrahub_testcontainers/models.py,sha256=ASYyvl7d_WQz_i7y8-3iab9hwwmCl3OCJavqVbe
 infrahub_testcontainers/performance_test.py,sha256=hvwiy6tc_lWniYqGkqfOXVGAmA_IV15VOZqbiD9ezno,6149
 infrahub_testcontainers/plugin.py,sha256=I3RuZQ0dARyKHuqCf0y1Yj731P2Mwf3BJUehRJKeWrs,5645
 infrahub_testcontainers/prometheus.yml,sha256=610xQEyj3xuVJMzPkC4m1fRnCrjGpiRBrXA2ytCLa54,599
-infrahub_server-1.3.1.dist-info/LICENSE.txt,sha256=TfPDBt3ar0uv_f9cqCDMZ5rIzW3CY8anRRd4PkL6ejs,34522
-infrahub_server-1.3.1.dist-info/METADATA,sha256=7WxSk_ctoonbM_snztUovCRsd9Lq-grShqcalwFQuEo,8205
-infrahub_server-1.3.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-infrahub_server-1.3.1.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
-infrahub_server-1.3.1.dist-info/RECORD,,
+infrahub_server-1.3.2.dist-info/LICENSE.txt,sha256=TfPDBt3ar0uv_f9cqCDMZ5rIzW3CY8anRRd4PkL6ejs,34522
+infrahub_server-1.3.2.dist-info/METADATA,sha256=ryVIpJ8RWv_Brr02affO2F-ZGjjAuz0ahV-OGLaIr7U,8205
+infrahub_server-1.3.2.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+infrahub_server-1.3.2.dist-info/entry_points.txt,sha256=UXIeFWDsrV-4IllNvUEd6KieYGzQfn9paga2YyABOQI,393
+infrahub_server-1.3.2.dist-info/RECORD,,