infrahub-server 1.3.0b6__py3-none-any.whl → 1.3.2__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/query/delete.py

@@ -21,7 +21,7 @@ class DeleteAfterTimeQuery(Query):
         // ---------------------
         // Reset edges with to time after timestamp
         // ---------------------
-        CALL {
+        CALL () {
             OPTIONAL MATCH (p)-[r]-(q)
             WHERE r.to > $timestamp
             SET r.to = NULL
@@ -33,7 +33,7 @@ class DeleteAfterTimeQuery(Query):
             // ---------------------
             // Delete edges with from time after timestamp timestamp
             // ---------------------
-            CALL {
+            CALL () {
                 OPTIONAL MATCH (p)-[r]->(q)
                 WHERE r.from > $timestamp
                 DELETE r
@@ -49,7 +49,7 @@ class DeleteAfterTimeQuery(Query):
             // ---------------------
             // Delete edges with from time after timestamp timestamp
             // ---------------------
-            CALL {
+            CALL () {
                 OPTIONAL MATCH (p)-[r]->(q)
                 WHERE r.from > $timestamp
                 DELETE r

infrahub/core/schema/attribute_parameters.py

@@ -8,6 +8,7 @@ from pydantic import ConfigDict, Field, model_validator
 from infrahub import config
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.models import HashableModel
+from infrahub.exceptions import ValidationError
 
 
 def get_attribute_parameters_class_for_kind(kind: str) -> type[AttributeParameters]:
@@ -124,16 +125,22 @@ class NumberAttributeParameters(AttributeParameters):
         return ranges
 
     def is_valid_value(self, value: int) -> bool:
-        if self.min_value is not None and value < self.min_value:
+        try:
+            self.check_valid_value(value=value, name="UNUSED")
+        except ValidationError:
             return False
+        return True
+
+    def check_valid_value(self, value: int, name: str) -> None:
+        if self.min_value is not None and value < self.min_value:
+            raise ValidationError({name: f"{value} is lower than the minimum allowed value {self.min_value!r}"})
         if self.max_value is not None and value > self.max_value:
-            return False
+            raise ValidationError({name: f"{value} is higher than the maximum allowed value {self.max_value!r}"})
         if value in self.get_excluded_single_values():
-            return False
+            raise ValidationError({name: f"{value} is in the excluded values"})
         for start, end in self.get_excluded_ranges():
             if start <= value <= end:
-                return False
-        return True
+                raise ValidationError({name: f"{value} is in an the excluded range {start}-{end}"})
 
 
 class NumberPoolParameters(AttributeParameters):

infrahub/core/schema/basenode_schema.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import keyword
 import os
+from collections import defaultdict
 from dataclasses import asdict, dataclass
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
@@ -10,7 +11,7 @@ from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
 from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
 
-from infrahub.core.constants import RelationshipCardinality, RelationshipKind
+from infrahub.core.constants import HashableModelState, RelationshipCardinality, RelationshipKind
 from infrahub.core.models import HashableModel, HashableModelDiff
 
 from .attribute_schema import AttributeSchema, get_attribute_schema_class_for_kind
@@ -514,7 +515,86 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             return UniquenessConstraintType.SUBSET_OF_HFID
         return UniquenessConstraintType.STANDARD
 
+    def _update_schema_paths(
+        self, schema_paths_list: list[str], field_name_update_map: dict[str, str], deleted_field_names: set[str]
+    ) -> list[str]:
+        """
+        For each schema_path (eg name__value, device__name_value), update the field name if the current name is
+        in field_name_update_map, remove the path if the field name is in deleted_field_names
+        """
+        updated_element_list = []
+        for schema_path in schema_paths_list:
+            split_path = schema_path.split("__", maxsplit=1)
+            current_field_name = split_path[0]
+            if current_field_name in deleted_field_names:
+                continue
+            new_field_name = field_name_update_map.get(current_field_name)
+            if not new_field_name:
+                updated_element_list.append(schema_path)
+                continue
+            rest_of_path = f"__{split_path[1]}" if len(split_path) > 1 else ""
+            new_element_str = f"{new_field_name}{rest_of_path}"
+            updated_element_list.append(new_element_str)
+        return updated_element_list
+
+    def handle_field_renames_and_deletes(self, other: BaseNodeSchema) -> None:
+        properties_to_update = [self.uniqueness_constraints, self.human_friendly_id, self.display_labels, self.order_by]
+        if not any(p for p in properties_to_update):
+            return
+
+        deleted_names: set[str] = set()
+        field_names_by_id = defaultdict(list)
+        for field in self.attributes + self.relationships:
+            if not field.id:
+                continue
+            field_names_by_id[field.id].append(field.name)
+        for field in other.attributes + other.relationships:
+            # identify fields deleted in the other schema
+            if field.state is HashableModelState.ABSENT:
+                deleted_names.add(field.name)
+            if not field.id:
+                continue
+            if field.name not in field_names_by_id[field.id]:
+                field_names_by_id[field.id].append(field.name)
+        # identify fields renamed from this schema to the other schema
+        renamed_field_name_map = {v[0]: v[-1] for v in field_names_by_id.values() if len(v) > 1}
+
+        if self.uniqueness_constraints:
+            updated_constraints = []
+            for constraint in self.uniqueness_constraints:
+                updated_constraint = self._update_schema_paths(
+                    schema_paths_list=constraint,
+                    field_name_update_map=renamed_field_name_map,
+                    deleted_field_names=deleted_names,
+                )
+                if updated_constraint:
+                    updated_constraints.append(updated_constraint)
+            self.uniqueness_constraints = updated_constraints
+        if self.human_friendly_id:
+            self.human_friendly_id = self._update_schema_paths(
+                schema_paths_list=self.human_friendly_id,
+                field_name_update_map=renamed_field_name_map,
+                deleted_field_names=deleted_names,
+            )
+        if self.display_labels:
+            self.display_labels = self._update_schema_paths(
+                schema_paths_list=self.display_labels,
+                field_name_update_map=renamed_field_name_map,
+                deleted_field_names=deleted_names,
+            )
+        if self.order_by:
+            self.order_by = self._update_schema_paths(
+                schema_paths_list=self.order_by,
+                field_name_update_map=renamed_field_name_map,
+                deleted_field_names=deleted_names,
+            )
+
     def update(self, other: HashableModel) -> Self:
+        # handle renamed/deleted field updates for schema properties here
+        # so that they can still be overridden during the call to `update()` below
+        if isinstance(other, BaseNodeSchema):
+            self.handle_field_renames_and_deletes(other=other)
+
         super().update(other=other)
 
         # Allow to specify empty string to remove existing fields values
@@ -551,6 +631,24 @@ class SchemaAttributePath:
     attribute_schema: AttributeSchema | None = None
     attribute_property_name: str | None = None
 
+    def __str__(self) -> str:
+        return self.to_string()
+
+    def to_string(self, field_name_override: str | None = None) -> str:
+        str_path = ""
+        if self.relationship_schema:
+            str_path += field_name_override or self.relationship_schema.name
+        if self.attribute_schema:
+            if str_path:
+                str_path += "__"
+                attr_name = self.attribute_schema.name
+            else:
+                attr_name = field_name_override or self.attribute_schema.name
+            str_path += attr_name
+        if self.attribute_property_name:
+            str_path += f"__{self.attribute_property_name}"
+        return str_path
+
     @property
     def is_type_attribute(self) -> bool:
         return bool(self.attribute_schema and not self.related_schema and not self.relationship_schema)
@@ -563,6 +661,14 @@ class SchemaAttributePath:
     def has_property(self) -> bool:
         return bool(self.attribute_property_name)
 
+    @property
+    def field_name(self) -> str | None:
+        if self.relationship_schema:
+            return self.relationship_schema.name
+        if self.attribute_schema:
+            return self.attribute_schema.name
+        return None
+
     @property
     def active_relationship_schema(self) -> RelationshipSchema:
         if self.relationship_schema:

infrahub/core/schema/schema_branch.py

@@ -710,7 +710,9 @@ class SchemaBranch:
                 ):
                     unique_attrs_in_constraints.add(schema_attribute_path.attribute_schema.name)
 
-            unique_attrs_in_attrs = {attr_schema.name for attr_schema in node_schema.unique_attributes}
+            unique_attrs_in_attrs = {
+                attr_schema.name for attr_schema in node_schema.unique_attributes if not attr_schema.inherited
+            }
             if unique_attrs_in_attrs == unique_attrs_in_constraints:
                 continue
 
@@ -822,11 +824,16 @@ class SchemaBranch:
                     ) from exc
 
     def _is_attr_combination_unique(
-        self, attrs_paths: list[str], uniqueness_constraints: list[list[str]] | None
+        self, attrs_paths: list[str], uniqueness_constraints: list[list[str]] | None, unique_attribute_names: list[str]
     ) -> bool:
         """
-        Return whether at least one combination of any length of `attrs_paths` is equal to a uniqueness constraint.
+        Return whether at least one combination of any length of `attrs_paths` is unique
         """
+        if unique_attribute_names:
+            for attr_path in attrs_paths:
+                for unique_attr_name in unique_attribute_names:
+                    if attr_path.startswith(unique_attr_name):
+                        return True
 
         if not uniqueness_constraints:
             return False
@@ -868,9 +875,14 @@ class SchemaBranch:
             if config.SETTINGS.main.schema_strict_mode:
                 # For every relationship referred within hfid, check whether the combination of attributes is unique is the peer schema node
                 for related_schema, attrs_paths in rel_schemas_to_paths.values():
-                    if not self._is_attr_combination_unique(attrs_paths, related_schema.uniqueness_constraints):
+                    if not self._is_attr_combination_unique(
+                        attrs_paths=attrs_paths,
+                        uniqueness_constraints=related_schema.uniqueness_constraints,
+                        unique_attribute_names=[a.name for a in related_schema.unique_attributes],
+                    ):
                         raise ValidationError(
-                            f"HFID of {node_schema.kind} refers peer {related_schema.kind} with a non-unique combination of attributes {attrs_paths}"
+                            f"HFID of {node_schema.kind} refers to peer {related_schema.kind}"
+                            f" with a non-unique combination of attributes {attrs_paths}"
                         )
 
     def validate_required_relationships(self) -> None:

infrahub/core/validators/attribute/min_max.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
+from infrahub import config
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
 from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
@@ -87,6 +88,10 @@ class AttributeNumberChecker(ConstraintCheckerInterface):
         return "attribute.number.update"
 
     def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        # Some invalid values may exist due to https://github.com/opsmill/infrahub/issues/6714.
+        if not config.SETTINGS.main.schema_strict_mode:
+            return False
+
         return request.constraint_name in (
             ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value,
             ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value,
@@ -94,7 +99,6 @@ class AttributeNumberChecker(ConstraintCheckerInterface):
         )
 
     async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
-        grouped_data_paths_list: list[GroupedDataPaths] = []
         if not request.schema_path.field_name:
             raise ValueError("field_name is not defined")
         attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
@@ -106,8 +110,9 @@ class AttributeNumberChecker(ConstraintCheckerInterface):
             and attribute_schema.parameters.max_value is None
             and attribute_schema.parameters.excluded_values is None
         ):
-            return grouped_data_paths_list
+            return []
 
+        grouped_data_paths_list: list[GroupedDataPaths] = []
         for query_class in self.query_classes:
             # TODO add exception handling
             query = await query_class.init(

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