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

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/node/resource_manager/ip_address_pool.py

@@ -18,6 +18,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.ipam.constants import IPAddressType
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -30,6 +31,7 @@ class CoreIPAddressPool(Node):
         data: dict[str, Any] | None = None,
         address_type: str | None = None,
         prefixlen: int | None = None,
+        at: Timestamp | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available
@@ -63,18 +65,18 @@ class CoreIPAddressPool(Node):
         next_address = await self.get_next(db=db, prefixlen=prefixlen)
 
         target_schema = registry.get_node_schema(name=address_type, branch=branch)
-        node = await Node.init(db=db, schema=target_schema, branch=branch)
+        node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
         try:
             await node.new(db=db, address=str(next_address), ip_namespace=ip_namespace, **data)
         except ValidationError as exc:
             raise ValueError(f"IPAddressPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
-        await node.save(db=db)
+        await node.save(db=db, at=at)
         reconciler = IpamReconciler(db=db, branch=branch)
         await reconciler.reconcile(ip_value=next_address, namespace=ip_namespace.id, node_uuid=node.get_id())
 
         if identifier:
             query_set = await IPAddressPoolSetReserved.init(
-                db=db, pool_id=self.id, identifier=identifier, address_id=node.id
+                db=db, pool_id=self.id, identifier=identifier, address_id=node.id, at=at
             )
             await query_set.execute(db=db)
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -20,6 +20,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
     from infrahub.core.ipam.constants import IPNetworkType
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -33,6 +34,7 @@ class CoreIPPrefixPool(Node):
         prefixlen: int | None = None,
         member_type: str | None = None,
         prefix_type: str | None = None,
+        at: Timestamp | None = None,
     ) -> Node:
         # Check if there is already a resource allocated with this identifier
         # if not, pull all existing prefixes and allocated the next available
@@ -68,20 +70,21 @@ class CoreIPPrefixPool(Node):
             )
 
         member_type = member_type or data.get("member_type", None) or self.default_member_type.value.value  # type: ignore[attr-defined]
+        data["member_type"] = member_type
 
         target_schema = registry.get_node_schema(name=prefix_type, branch=branch)
-        node = await Node.init(db=db, schema=target_schema, branch=branch)
+        node = await Node.init(db=db, schema=target_schema, branch=branch, at=at)
         try:
-            await node.new(db=db, prefix=str(next_prefix), member_type=member_type, ip_namespace=ip_namespace, **data)
+            await node.new(db=db, prefix=str(next_prefix), ip_namespace=ip_namespace, **data)
         except ValidationError as exc:
             raise ValueError(f"IPPrefixPool: {self.name.value} | {exc!s}") from exc  # type: ignore[attr-defined]
-        await node.save(db=db)
+        await node.save(db=db, at=at)
         reconciler = IpamReconciler(db=db, branch=branch)
         await reconciler.reconcile(ip_value=next_prefix, namespace=ip_namespace.id, node_uuid=node.get_id())
 
         if identifier:
             query_set = await PrefixPoolSetReserved.init(
-                db=db, pool_id=self.id, identifier=identifier, prefix_id=node.id
+                db=db, pool_id=self.id, identifier=identifier, prefix_id=node.id, at=at
             )
             await query_set.execute(db=db)
 

infrahub/core/node/resource_manager/number_pool.py

@@ -12,6 +12,7 @@ from .. import Node
 if TYPE_CHECKING:
     from infrahub.core.attribute import BaseAttribute
     from infrahub.core.branch import Branch
+    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -41,6 +42,7 @@ class CoreNumberPool(Node):
         node: Node,
         attribute: BaseAttribute,
         identifier: str | None = None,
+        at: Timestamp | None = None,
     ) -> int:
         identifier = identifier or node.get_id()
         # Check if there is already a resource allocated with this identifier
@@ -56,7 +58,7 @@ class CoreNumberPool(Node):
         number = await self.get_next(db=db, branch=branch, attribute=attribute)
 
         query_set = await NumberPoolSetReserved.init(
-            db=db, pool_id=self.get_id(), identifier=identifier, reserved=number
+            db=db, pool_id=self.get_id(), identifier=identifier, reserved=number, at=at
         )
         await query_set.execute(db=db)
         return number

infrahub/core/node/standard.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+from enum import Enum
 from typing import TYPE_CHECKING, Any, Optional, Union, get_args, get_origin
 from uuid import UUID
 
@@ -191,6 +192,9 @@ class StandardNode(BaseModel):
                 continue
 
             attr_value = getattr(self, attr_name)
+            if isinstance(attr_value, Enum):
+                attr_value = attr_value.value
+
             field_type = self.guess_field_type(field)
 
             if attr_value is None:

infrahub/core/query/branch.py

@@ -3,43 +3,12 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 from infrahub import config
-from infrahub.core.constants import RelationshipStatus
 from infrahub.core.query import Query, QueryType
 
 if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-class AddNodeToBranch(Query):
-    name: str = "node_add_to_branch"
-    insert_return: bool = False
-
-    type: QueryType = QueryType.WRITE
-
-    def __init__(self, node_id: int, **kwargs: Any):
-        self.node_id = node_id
-        super().__init__(**kwargs)
-
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        query = """
-        MATCH (root:Root)
-        MATCH (d) WHERE %(id_func)s(d) = $node_id
-        WITH root,d
-        CREATE (d)-[r:IS_PART_OF { branch: $branch, branch_level: $branch_level, from: $now, status: $status }]->(root)
-        RETURN %(id_func)s(r)
-        """ % {
-            "id_func": db.get_id_function_name(),
-        }
-
-        self.params["node_id"] = db.to_database_id(self.node_id)
-        self.params["now"] = self.at.to_string()
-        self.params["branch"] = self.branch.name
-        self.params["branch_level"] = self.branch.hierarchy_level
-        self.params["status"] = RelationshipStatus.ACTIVE.value
-
-        self.add_to_query(query)
-
-
 class DeleteBranchRelationshipsQuery(Query):
     name: str = "delete_branch_relationships"
     insert_return: bool = False
@@ -52,31 +21,31 @@ class DeleteBranchRelationshipsQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         query = """
-        MATCH (s)-[r1]-(d)
-        WHERE r1.branch = $branch_name
-        DELETE r1
-
-        WITH collect(DISTINCT s) + collect(DISTINCT d) AS nodes
-
-        // Collect node IDs for filtering
-        WITH nodes, [n in nodes | n.uuid] as nodes_uuids
-
-        // Also delete agnostic relationships that would not have been deleted above
-        MATCH (s2: Node)-[r2]-(d2)
-        WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
-        AND s2.uuid IN nodes_uuids
-        DELETE r2
-
-        WITH nodes, collect(DISTINCT s2) + collect(DISTINCT d2) as additional_nodes
-
-        WITH nodes + additional_nodes as nodes
-
-        // Delete nodes that are no longer connected to any other nodes
-        UNWIND nodes AS n
-        WITH DISTINCT n
-        MATCH (n)
-        WHERE NOT exists((n)--())
-        DELETE n
+// delete all relationships on this branch
+MATCH (s)-[r1]-(d)
+WHERE r1.branch = $branch_name
+CALL (r1) {
+  DELETE r1
+} IN TRANSACTIONS
+
+// check for any orphaned Node vertices and delete them
+WITH collect(DISTINCT s.uuid) + collect(DISTINCT d.uuid) AS nodes_uuids
+MATCH (s2:Node)-[r2]-(d2)
+WHERE NOT exists((s2)-[:IS_PART_OF]-(:Root))
+AND s2.uuid IN nodes_uuids
+CALL (r2) {
+  DELETE r2
+} IN TRANSACTIONS
+
+// reduce results to a single row
+WITH 1 AS one LIMIT 1
+
+// find any orphaned vertices and delete them
+MATCH (n)
+WHERE NOT exists((n)--())
+CALL (n) {
+  DELETE n
+} IN TRANSACTIONS
         """
         self.params["branch_name"] = self.branch_name
         self.add_to_query(query)