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

infrahub/core/migrations/schema/tasks.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub_sdk.batch import InfrahubBatch
 from prefect import flow, task
@@ -33,7 +33,7 @@ async def schema_apply_migrations(message: SchemaApplyMigrationData, service: In
     for migration in message.migrations:
         log.info(f"Preparing migration for {migration.migration_name!r} ({migration.routing_key})")
 
-        new_node_schema: Optional[MainSchemaTypes] = None
+        new_node_schema: MainSchemaTypes | None = None
 
         if message.new_schema.has(name=migration.path.schema_kind):
             new_node_schema = message.new_schema.get(name=migration.path.schema_kind)

infrahub/core/migrations/shared.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Sequence
 
 from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Self
@@ -43,13 +43,11 @@ class SchemaMigration(BaseModel):
     name: str = Field(..., description="Name of the migration")
     queries: Sequence[type[MigrationQuery]] = Field(..., description="List of queries to execute for this migration")
 
-    new_node_schema: Optional[Union[NodeSchema, GenericSchema]] = None
-    previous_node_schema: Optional[Union[NodeSchema, GenericSchema]] = None
+    new_node_schema: NodeSchema | GenericSchema | None = None
+    previous_node_schema: NodeSchema | GenericSchema | None = None
     schema_path: SchemaPath
 
-    async def execute(
-        self, db: InfrahubDatabase, branch: Branch, at: Optional[Union[Timestamp, str]] = None
-    ) -> MigrationResult:
+    async def execute(self, db: InfrahubDatabase, branch: Branch, at: Timestamp | str | None = None) -> MigrationResult:
         async with db.start_transaction() as ts:
             result = MigrationResult()
 
@@ -65,13 +63,13 @@ class SchemaMigration(BaseModel):
         return result
 
     @property
-    def new_schema(self) -> Union[NodeSchema, GenericSchema]:
+    def new_schema(self) -> NodeSchema | GenericSchema:
         if self.new_node_schema:
             return self.new_node_schema
         raise ValueError("new_node_schema hasn't been initialized")
 
     @property
-    def previous_schema(self) -> Union[NodeSchema, GenericSchema]:
+    def previous_schema(self) -> NodeSchema | GenericSchema:
         if self.previous_node_schema:
             return self.previous_node_schema
         raise ValueError("previous_node_schema hasn't been initialized")
@@ -120,15 +118,17 @@ class GraphMigration(BaseModel):
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
         async with db.start_transaction() as ts:
-            result = MigrationResult()
+            return await self.do_execute(db=ts)
 
-            for migration_query in self.queries:
-                try:
-                    query = await migration_query.init(db=ts)
-                    await query.execute(db=ts)
-                except Exception as exc:
-                    result.errors.append(str(exc))
-                    return result
+    async def do_execute(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        for migration_query in self.queries:
+            try:
+                query = await migration_query.init(db=db)
+                await query.execute(db=db)
+            except Exception as exc:
+                result.errors.append(str(exc))
+                return result
 
         return result
 

infrahub/core/models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import hashlib
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub_sdk.utils import compare_lists, deep_merge_dict, duplicates, intersection
 from pydantic import BaseModel, ConfigDict, Field
@@ -125,7 +125,7 @@ class SchemaUpdateValidationError(BaseModel):
     model_config = ConfigDict(extra="forbid")
     path: SchemaPath
     error: UpdateValidationErrorType
-    message: Optional[str] = None
+    message: str | None = None
 
     def to_string(self) -> str:
         return f"{self.error.value!r}: {self.path.schema_kind} {self.path.field_name} {self.message}"
@@ -181,6 +181,15 @@ class SchemaUpdateValidationResult(BaseModel):
 
         for schema_name, schema_diff in self.diff.changed.items():
             schema_node = schema.get(name=schema_name, duplicate=False)
+            if "inherit_from" in schema_diff.changed:
+                self.migrations.append(
+                    SchemaUpdateMigrationInfo(
+                        path=SchemaPath(  # type: ignore[call-arg]
+                            schema_kind=schema_name, path_type=SchemaPathType.NODE
+                        ),
+                        migration_name="node.inherit_from.update",
+                    )
+                )
 
             # Nothing to do today if we add a new attribute to a node in the schema
             # for node_field_name, _ in schema_diff.added.items():
@@ -341,9 +350,9 @@ class SchemaUpdateValidationResult(BaseModel):
 
 class HashableModelDiff(BaseModel):
     model_config = ConfigDict(extra="forbid")
-    added: dict[str, Optional[HashableModelDiff]] = Field(default_factory=dict)
-    changed: dict[str, Optional[HashableModelDiff]] = Field(default_factory=dict)
-    removed: dict[str, Optional[HashableModelDiff]] = Field(default_factory=dict)
+    added: dict[str, HashableModelDiff | None] = Field(default_factory=dict)
+    changed: dict[str, HashableModelDiff | None] = Field(default_factory=dict)
+    removed: dict[str, HashableModelDiff | None] = Field(default_factory=dict)
 
     @property
     def has_diff(self) -> bool:
@@ -353,7 +362,7 @@ class HashableModelDiff(BaseModel):
 class HashableModel(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
-    id: Optional[str] = None
+    id: str | None = None
     state: HashableModelState = HashableModelState.PRESENT
 
     _exclude_from_hash: list[str] = []

infrahub/core/node/__init__.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Sequence, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Sequence, TypeVar, overload
 
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
@@ -9,6 +9,7 @@ from infrahub_sdk.uuidt import UUIDT
 from infrahub.core import registry
 from infrahub.core.changelog.models import NodeChangelog
 from infrahub.core.constants import (
+    GLOBAL_BRANCH_NAME,
     OBJECT_TEMPLATE_NAME_ATTR,
     OBJECT_TEMPLATE_RELATIONSHIP_NAME,
     BranchSupportType,
@@ -28,6 +29,7 @@ from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
+from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
 from .base import BaseNode, BaseNodeMeta, BaseNodeOptions
@@ -61,7 +63,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
-    def get_schema(self) -> Union[NodeSchema, ProfileSchema, TemplateSchema]:
+    def get_schema(self) -> NodeSchema | ProfileSchema | TemplateSchema:
         return self._schema
 
     def get_kind(self) -> str:
@@ -78,17 +80,18 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     def get_updated_at(self) -> Timestamp | None:
         return self._updated_at
 
-    async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> Optional[list[str]]:
+    async def get_hfid(self, db: InfrahubDatabase, include_kind: bool = False) -> list[str] | None:
         """Return the Human friendly id of the node."""
         if not self._schema.human_friendly_id:
             return None
 
-        hfid = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid_values = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid = [value for value in hfid_values if value is not None]
         if include_kind:
             return [self.get_kind()] + hfid
         return hfid
 
-    async def get_hfid_as_string(self, db: InfrahubDatabase, include_kind: bool = False) -> Optional[str]:
+    async def get_hfid_as_string(self, db: InfrahubDatabase, include_kind: bool = False) -> str | None:
         """Return the Human friendly id of the node in string format separated with a dunder (__) ."""
         hfid = await self.get_hfid(db=db, include_kind=include_kind)
         if not hfid:
@@ -158,18 +161,18 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return f"{self.get_kind()}(ID: {str(self.id)})"
 
-    def __init__(self, schema: Union[NodeSchema, ProfileSchema, TemplateSchema], branch: Branch, at: Timestamp):
-        self._schema: Union[NodeSchema, ProfileSchema, TemplateSchema] = schema
+    def __init__(self, schema: NodeSchema | ProfileSchema | TemplateSchema, branch: Branch, at: Timestamp):
+        self._schema: NodeSchema | ProfileSchema | TemplateSchema = schema
         self._branch: Branch = branch
         self._at: Timestamp = at
         self._existing: bool = False
 
-        self._updated_at: Optional[Timestamp] = None
+        self._updated_at: Timestamp | None = None
         self.id: str = None
         self.db_id: str = None
 
-        self._source: Optional[Node] = None
-        self._owner: Optional[Node] = None
+        self._source: Node | None = None
+        self._owner: Node | None = None
         self._is_protected: bool = None
         self._computed_jinja2_attributes: list[str] = []
 
@@ -189,10 +192,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str],
+        schema: NodeSchema | ProfileSchema | TemplateSchema | str,
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = ...,
-        at: Optional[Union[Timestamp, str]] = ...,
+        branch: Branch | str | None = ...,
+        at: Timestamp | str | None = ...,
     ) -> Self: ...
 
     @overload
@@ -201,17 +204,17 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         cls,
         schema: type[SchemaProtocol],
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = ...,
-        at: Optional[Union[Timestamp, str]] = ...,
+        branch: Branch | str | None = ...,
+        at: Timestamp | str | None = ...,
     ) -> SchemaProtocol: ...
 
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str, type[SchemaProtocol]],
+        schema: NodeSchema | ProfileSchema | TemplateSchema | str | type[SchemaProtocol],
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = None,
-        at: Optional[Union[Timestamp, str]] = None,
+        branch: Branch | str | None = None,
+        at: Timestamp | str | None = None,
     ) -> Self | SchemaProtocol:
         attrs: dict[str, Any] = {}
 
@@ -308,13 +311,13 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for attribute_name in template._attributes:
             if attribute_name in list(fields) + [OBJECT_TEMPLATE_NAME_ATTR]:
                 continue
-            fields[attribute_name] = {"value": getattr(template, attribute_name).value}
+            fields[attribute_name] = {"value": getattr(template, attribute_name).value, "source": template.id}
 
         for relationship_name in template._relationships:
             relationship_schema = template._schema.get_relationship(name=relationship_name)
             if (
                 relationship_name in list(fields)
-                or relationship_schema.kind != RelationshipKind.ATTRIBUTE
+                or relationship_schema.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC]
                 or relationship_name == OBJECT_TEMPLATE_RELATIONSHIP_NAME
             ):
                 continue
@@ -544,7 +547,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         )
         return attr
 
-    async def process_label(self, db: Optional[InfrahubDatabase] = None) -> None:  # noqa: ARG002
+    async def process_label(self, db: InfrahubDatabase | None = None) -> None:  # noqa: ARG002
         # If there label and name are both defined for this node
         #  if label is not define, we'll automatically populate it with a human friendy vesion of name
         if not self._existing and hasattr(self, "label") and hasattr(self, "name"):
@@ -552,7 +555,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 self.label.value = " ".join([word.title() for word in self.name.value.split("_")])
                 self.label.is_default = False
 
-    async def new(self, db: InfrahubDatabase, id: Optional[str] = None, **kwargs: Any) -> Self:
+    async def new(self, db: InfrahubDatabase, id: str | None = None, **kwargs: Any) -> Self:
         if id and not is_valid_uuid(id):
             raise ValidationError({"id": f"{id} is not a valid UUID"})
         if id:
@@ -575,9 +578,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     async def load(
         self,
         db: InfrahubDatabase,
-        id: Optional[str] = None,
-        db_id: Optional[str] = None,
-        updated_at: Optional[Union[Timestamp, str]] = None,
+        id: str | None = None,
+        db_id: str | None = None,
+        updated_at: Timestamp | str | None = None,
         **kwargs: Any,
     ) -> Self:
         self.id = id
@@ -628,7 +631,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return node_changelog
 
     async def _update(
-        self, db: InfrahubDatabase, at: Optional[Timestamp] = None, fields: list[str] | None = None
+        self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None
     ) -> NodeChangelog:
         """Update the node in the database if needed."""
 
@@ -650,7 +653,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 processed_relationships.append(name)
                 rel: RelationshipManager = getattr(self, name)
                 updated_relationship = await rel.save(at=update_at, db=db)
-                node_changelog.add_relationship(relationship=updated_relationship)
+                node_changelog.add_relationship(relationship_changelog=updated_relationship)
 
         if len(processed_relationships) != len(self._relationships):
             # Analyze if the node has a parent and add it to the changelog if missing
@@ -663,7 +666,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         node_changelog.display_label = await self.render_display_label(db=db)
         return node_changelog
 
-    async def save(self, db: InfrahubDatabase, at: Optional[Timestamp] = None, fields: list[str] | None = None) -> Self:
+    async def save(self, db: InfrahubDatabase, at: Timestamp | None = None, fields: list[str] | None = None) -> Self:
         """Create or Update the Node in the database."""
 
         save_at = Timestamp(at)
@@ -675,7 +678,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         self._node_changelog = await self._create(at=save_at, db=db)
         return self
 
-    async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def delete(self, db: InfrahubDatabase, at: Timestamp | None = None) -> None:
         """Delete the Node in the database."""
 
         delete_at = Timestamp(at)
@@ -690,16 +693,17 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             if deleted_attribute:
                 node_changelog.add_attribute(attribute=deleted_attribute)
 
-        # Go over the list of relationships and update them one by one
-        for name in self._relationships:
-            rel: RelationshipManager = getattr(self, name)
-            updated_relationship = await rel.delete(at=delete_at, db=db)
-            node_changelog.add_relationship(relationship=updated_relationship)
-
-        # Need to check if there are some unidirectional relationship as well
-        # For example, if we delete a tag, we must check the permissions and update all the relationships pointing at it
         branch = self.get_branch_based_on_support_type()
 
+        delete_query = await RelationshipDeleteAllQuery.init(
+            db=db, node_id=self.get_id(), branch=branch, at=delete_at, branch_agnostic=branch.name == GLOBAL_BRANCH_NAME
+        )
+        await delete_query.execute(db=db)
+
+        deleted_relationships_changelogs = delete_query.get_deleted_relationships_changelog(self._schema)
+        for relationship_changelog in deleted_relationships_changelogs:
+            node_changelog.add_relationship(relationship_changelog=relationship_changelog)
+
         # Update the relationship to the branch itself
         query = await NodeGetListQuery.init(
             db=db,
@@ -767,7 +771,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     response[field_name] = None
                 continue
 
-            field: Optional[BaseAttribute] = getattr(self, field_name, None)
+            field: BaseAttribute | None = getattr(self, field_name, None)
 
             if not field:
                 response[field_name] = None
@@ -829,7 +833,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return changed
 
-    async def render_display_label(self, db: Optional[InfrahubDatabase] = None) -> str:  # noqa: ARG002
+    async def render_display_label(self, db: InfrahubDatabase | None = None) -> str:  # noqa: ARG002
         if not self._schema.display_labels:
             return repr(self)
 

infrahub/core/node/base.py

@@ -1,13 +1,11 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from ..utils import SubclassWithMeta, SubclassWithMeta_Meta
 
 
 class BaseOptions:
-    name: Optional[str] = None
-    description: Optional[str] = None
+    name: str | None = None
+    description: str | None = None
 
     _frozen: bool = False
 

infrahub/core/node/constraints/attribute_uniqueness.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -18,7 +18,7 @@ class NodeAttributeUniquenessConstraint(NodeConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None:
+    async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None:
         at = Timestamp(at)
         node_schema = node.get_schema()
         for unique_attr in node_schema.unique_attributes:

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Iterable, Optional
+from typing import TYPE_CHECKING, Iterable
 
 from infrahub.core import registry
 from infrahub.core.constants import NULL_VALUE
@@ -9,6 +9,11 @@ from infrahub.core.schema import (
     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,
@@ -16,7 +21,7 @@ from infrahub.core.validators.uniqueness.model import (
     QueryRelationshipAttributePath,
 )
 from infrahub.core.validators.uniqueness.query import NodeUniqueAttributeConstraintQuery
-from infrahub.exceptions import ValidationError
+from infrahub.exceptions import HFIDViolatedError, ValidationError
 
 from .interface import NodeConstraintInterface
 
@@ -39,15 +44,15 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
         self,
         updated_node: Node,
         node_schema: MainSchemaTypes,
-        path_groups: list[list[SchemaAttributePath]],
-        filters: Optional[list[str]] = None,
+        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
+        filters: list[str] | None = None,
     ) -> NodeUniquenessQueryRequest:
         query_request = NodeUniquenessQueryRequest(kind=node_schema.kind)
-        for path_group in path_groups:
+        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 path_group:
+            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
@@ -118,71 +123,118 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                 )
         return node_value_combination
 
-    def _check_one_constraint_group(
-        self, schema_attribute_path_values: list[SchemaAttributePathValue], results_index: UniquenessQueryResultsIndex
-    ) -> None:
-        # constraint cannot be violated if this node is missing any values
-        if any(sapv.value is None for sapv in schema_attribute_path_values):
-            return
-
-        matching_node_ids = results_index.get_node_ids_for_value_group(schema_attribute_path_values)
-        if not matching_node_ids:
-            return
-        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)
-        uniqueness_constraint_string = "-".join(uniqueness_constraint_fields)
-        error_msg = f"Violates uniqueness constraint '{uniqueness_constraint_string}'"
-        errors = [ValidationError({field_name: error_msg}) for field_name in uniqueness_constraint_fields]
-        raise ValidationError(errors)
-
-    async def _check_results(
+    async def _get_violations(
         self,
         updated_node: Node,
-        path_groups: list[list[SchemaAttributePath]],
+        uniqueness_constraint_paths: list[SchemaUniquenessConstraintPath],
         query_results: Iterable[QueryResult],
-    ) -> None:
+    ) -> list[UniquenessConstraintViolation]:
         results_index = UniquenessQueryResultsIndex(
             query_results=query_results, exclude_node_ids={updated_node.get_id()}
         )
-        for path_group in path_groups:
+        violations = []
+        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=path_group
+                updated_node=updated_node, path_group=uniqueness_constraint_path.attributes_paths
             )
-            self._check_one_constraint_group(
-                schema_attribute_path_values=schema_attribute_path_values, results_index=results_index
+
+            # constraint cannot be violated if this node is missing any values
+            if any(sapv.value is None for sapv in schema_attribute_path_values):
+                continue
+
+            matching_node_ids = results_index.get_node_ids_for_value_group(schema_attribute_path_values)
+            if not matching_node_ids:
+                continue
+
+            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,
+                )
             )
 
-    async def _check_one_schema(
+        return violations
+
+    async def _get_single_schema_violations(
         self,
         node: Node,
         node_schema: MainSchemaTypes,
-        at: Optional[Timestamp] = None,
-        filters: Optional[list[str]] = None,
-    ) -> None:
+        at: Timestamp | None = None,
+        filters: list[str] | None = None,
+    ) -> list[UniquenessConstraintViolation]:
         schema_branch = self.db.schema.get_schema_branch(name=self.branch.name)
-        path_groups = node_schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+
+        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, path_groups=path_groups, filters=filters
+            updated_node=node,
+            node_schema=node_schema,
+            uniqueness_constraint_paths=uniqueness_constraint_paths,
+            filters=filters,
         )
         if not query_request:
-            return
+            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)
-        await self._check_results(updated_node=node, path_groups=path_groups, query_results=query.get_results())
+        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:
+                return frozenset()
+            return frozenset(frozenset(uc) for uc in schema.uniqueness_constraints)
 
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None:
         node_schema = node.get_schema()
-        schemas_to_check: list[MainSchemaTypes] = [node_schema]
+        include_node_schema = True
+        frozen_node_constraints = _frozen_constraints(node_schema)
+        schemas_to_check: list[MainSchemaTypes] = []
         if node_schema.inherit_from:
             for parent_schema_name in node_schema.inherit_from:
                 parent_schema = self.schema_branch.get(name=parent_schema_name, duplicate=False)
-                if parent_schema.uniqueness_constraints:
-                    schemas_to_check.append(parent_schema)
+                if not parent_schema.uniqueness_constraints:
+                    continue
+                schemas_to_check.append(parent_schema)
+                frozen_parent_constraints = _frozen_constraints(parent_schema)
+                if frozen_node_constraints <= frozen_parent_constraints:
+                    include_node_schema = False
+
+        if include_node_schema:
+            schemas_to_check.append(node_schema)
+
+        violations = []
         for schema in schemas_to_check:
-            await self._check_one_schema(node=node, node_schema=schema, at=at, filters=filters)
+            schema_violations = await self._get_single_schema_violations(
+                node=node, node_schema=schema, at=at, filters=filters
+            )
+            violations.extend(schema_violations)
+
+        is_hfid_violated = any(violation.typ == UniquenessConstraintType.HFID for violation in violations)
+
+        for violation in violations:
+            if violation.typ == UniquenessConstraintType.STANDARD or (
+                violation.typ == UniquenessConstraintType.SUBSET_OF_HFID and not is_hfid_violated
+            ):
+                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+                raise ValidationError(error_msg)
+
+        for violation in violations:
+            if violation.typ == UniquenessConstraintType.HFID:
+                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+                raise HFIDViolatedError(error_msg, matching_nodes_ids=violation.nodes_ids)

infrahub/core/node/constraints/interface.py

@@ -1,5 +1,4 @@
 from abc import ABC, abstractmethod
-from typing import Optional
 
 from infrahub.core.node import Node
 from infrahub.core.timestamp import Timestamp
@@ -7,4 +6,4 @@ from infrahub.core.timestamp import Timestamp
 
 class NodeConstraintInterface(ABC):
     @abstractmethod
-    async def check(self, node: Node, at: Optional[Timestamp] = None, filters: Optional[list[str]] = None) -> None: ...
+    async def check(self, node: Node, at: Timestamp | None = None, filters: list[str] | None = None) -> None: ...

infrahub/core/node/delete_validator.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from enum import Enum
-from typing import Iterable, Optional, Union
+from typing import Iterable
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
@@ -124,16 +124,14 @@ class NodeDeleteValidator:
         self._all_schemas_map = schema_branch.get_all(duplicate=False)
         self.index: NodeDeleteIndex = NodeDeleteIndex(all_schemas_map=self._all_schemas_map)
 
-    async def get_ids_to_delete(self, nodes: Iterable[Node], at: Optional[Union[Timestamp, str]] = None) -> set[str]:
+    async def get_ids_to_delete(self, nodes: Iterable[Node], at: Timestamp | str | None = None) -> set[str]:
         start_schemas = {node.get_schema() for node in nodes}
         self.index.index(start_schemas=start_schemas)
         at = Timestamp(at)
 
         return await self._analyze_delete_dependencies(start_nodes=nodes, at=at)
 
-    async def _analyze_delete_dependencies(
-        self, start_nodes: Iterable[Node], at: Optional[Union[Timestamp, str]]
-    ) -> set[str]:
+    async def _analyze_delete_dependencies(self, start_nodes: Iterable[Node], at: Timestamp | str | None) -> set[str]:
         full_relationship_identifiers = self.index.get_relationship_identifiers()
         if not full_relationship_identifiers:
             return {node.get_id() for node in start_nodes}