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

infrahub/core/migrations/schema/tasks.py

@@ -10,7 +10,7 @@ from prefect.logging import get_run_logger
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.migrations import MIGRATION_MAP
 from infrahub.core.path import SchemaPath  # noqa: TC001
-from infrahub.services import services
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.utils import add_branch_tag
 
 from .models import SchemaApplyMigrationData, SchemaMigrationPathResponseData
@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 
 
 @flow(name="schema_apply_migrations", flow_run_name="Apply schema migrations", persist_result=True)
-async def schema_apply_migrations(message: SchemaApplyMigrationData) -> list[str]:
+async def schema_apply_migrations(message: SchemaApplyMigrationData, service: InfrahubServices) -> list[str]:
     await add_branch_tag(branch_name=message.branch.name)
     log = get_run_logger()
 
@@ -34,7 +34,6 @@ async def schema_apply_migrations(message: SchemaApplyMigrationData) -> list[str
         log.info(f"Preparing migration for {migration.migration_name!r} ({migration.routing_key})")
 
         new_node_schema: Optional[MainSchemaTypes] = None
-        previous_node_schema: Optional[MainSchemaTypes] = None
 
         if message.new_schema.has(name=migration.path.schema_kind):
             new_node_schema = message.new_schema.get(name=migration.path.schema_kind)
@@ -56,6 +55,7 @@ async def schema_apply_migrations(message: SchemaApplyMigrationData) -> list[str
             new_node_schema=new_node_schema,
             previous_node_schema=previous_node_schema,
             schema_path=migration.path,
+            service=service,
         )
 
     async for _, result in batch.execute():
@@ -64,7 +64,7 @@ async def schema_apply_migrations(message: SchemaApplyMigrationData) -> list[str
     return error_messages
 
 
-@task(
+@task(  # type: ignore[arg-type]
     name="schema-path-migrate",
     task_run_name="Migrate Schema Path {migration_name} on {branch.name}",
     description="Apply a given migration to the database",
@@ -75,10 +75,10 @@ async def schema_path_migrate(
     branch: Branch,
     migration_name: str,
     schema_path: SchemaPath,
+    service: InfrahubServices,
     new_node_schema: MainSchemaTypes | None = None,
     previous_node_schema: MainSchemaTypes | None = None,
 ) -> SchemaMigrationPathResponseData:
-    service = services.service
     log = get_run_logger()
 
     async with service.database.start_session() as db:

infrahub/core/migrations/shared.py

@@ -58,7 +58,7 @@ class SchemaMigration(BaseModel):
                     query = await migration_query.init(db=ts, branch=branch, at=at, migration=self)
                     await query.execute(db=ts)
                     result.nbr_migrations_executed += query.get_nbr_migrations_executed()
-                except Exception as exc:  # pylint: disable=broad-exception-caught
+                except Exception as exc:
                     result.errors.append(str(exc))
                     return result
 
@@ -126,7 +126,7 @@ class GraphMigration(BaseModel):
                 try:
                     query = await migration_query.init(db=ts)
                     await query.execute(db=ts)
-                except Exception as exc:  # pylint: disable=broad-exception-caught
+                except Exception as exc:
                     result.errors.append(str(exc))
                     return result
 
@@ -141,7 +141,7 @@ class InternalSchemaMigration(BaseModel):
 
     @staticmethod
     def get_internal_schema() -> SchemaBranch:
-        from infrahub.core.schema.schema_branch import SchemaBranch  # pylint: disable=import-outside-toplevel
+        from infrahub.core.schema.schema_branch import SchemaBranch
 
         # load the internal schema from
         schema = SchemaRoot(**internal_schema)
@@ -167,7 +167,7 @@ class InternalSchemaMigration(BaseModel):
             try:
                 execution_result = await migration.execute(db=db, branch=default_branch)
                 result.errors.extend(execution_result.errors)
-            except Exception as exc:  # pylint: disable=broad-exception-caught
+            except Exception as exc:
                 result.errors.append(str(exc))
                 return result
 

infrahub/core/models.py

@@ -105,7 +105,6 @@ class SchemaDiff(BaseModel):
 
         indent_str = " " * indentation
 
-        # pylint: disable=too-many-nested-blocks
         for node_action, node_info in data.items():
             for node_name, elements in node_info.items():
                 print(f"{str(node_name).ljust(column_size)} | {str(node_action).title()}")
@@ -152,7 +151,7 @@ class SchemaUpdateConstraintInfo(BaseModel):
         return "schema.validator.path"
 
     def __hash__(self) -> int:
-        return hash((type(self),) + tuple([self.constraint_name + self.path.get_path()]))
+        return hash((type(self),) + tuple(self.constraint_name + self.path.get_path()))
 
 
 class SchemaUpdateValidationResult(BaseModel):
@@ -170,7 +169,7 @@ class SchemaUpdateValidationResult(BaseModel):
         return obj
 
     def process_diff(self, schema: SchemaBranch) -> None:
-        for schema_name, schema_diff in self.diff.removed.items():
+        for schema_name in self.diff.removed.keys():
             self.migrations.append(
                 SchemaUpdateMigrationInfo(
                     path=SchemaPath(  # type: ignore[call-arg]
@@ -331,7 +330,7 @@ class SchemaUpdateValidationResult(BaseModel):
 
     def add_validator_for_migration(self, validator_map: dict[str, Any]) -> None:
         for migration in self.migrations:
-            if validator_map.get(migration.migration_name, None):
+            if validator_map.get(migration.migration_name):
                 self.constraints.append(
                     SchemaUpdateConstraintInfo(
                         path=migration.path,
@@ -384,7 +383,7 @@ class HashableModel(BaseModel):
                 md5hash.update(item)
 
         if display_values:
-            from rich import print as rprint  # pylint: disable=import-outside-toplevel
+            from rich import print as rprint
 
             rprint(tuple(values))
 
@@ -494,8 +493,8 @@ class HashableModel(BaseModel):
             raise ValueError(f"Unable to merge the list for {field_name}, some items have the same _sorting_id")
 
         shared_ids = intersection(list(local_sub_items.keys()), list(other_sub_items.keys()))
-        local_only_ids = set(list(local_sub_items.keys())) - set(shared_ids)
-        other_only_ids = set(list(other_sub_items.keys())) - set(shared_ids)
+        local_only_ids = set(local_sub_items.keys()) - set(shared_ids)
+        other_only_ids = set(other_sub_items.keys()) - set(shared_ids)
 
         new_list = [value for key, value in local_sub_items.items() if key in local_only_ids]
         new_list.extend(
@@ -536,7 +535,7 @@ class HashableModel(BaseModel):
             if attr_other is None or attr_local == attr_other:
                 continue
 
-            if attr_local is None or isinstance(attr_other, (int, str, bool, float)):
+            if attr_local is None or isinstance(attr_other, int | str | bool | float):
                 setattr(self, field_name, attr_other)
                 continue
 

infrahub/core/node/__init__.py

@@ -1,17 +1,26 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Optional, Sequence, TypeVar, Union, overload
 
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
 
 from infrahub.core import registry
-from infrahub.core.constants import BranchSupportType, ComputedAttributeKind, InfrahubKind, RelationshipCardinality
+from infrahub.core.changelog.models import NodeChangelog
+from infrahub.core.constants import (
+    OBJECT_TEMPLATE_NAME_ATTR,
+    OBJECT_TEMPLATE_RELATIONSHIP_NAME,
+    BranchSupportType,
+    ComputedAttributeKind,
+    InfrahubKind,
+    RelationshipCardinality,
+    RelationshipKind,
+)
 from infrahub.core.constants.schema import SchemaElementPathType
-from infrahub.core.protocols import CoreNumberPool
+from infrahub.core.protocols import CoreNumberPool, CoreObjectTemplate
 from infrahub.core.query.node import NodeCheckIDQuery, NodeCreateAllQuery, NodeDeleteQuery, NodeGetListQuery
-from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, RelationshipSchema
+from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, RelationshipSchema, TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
 from infrahub.support.macro import MacroDefinition
@@ -42,21 +51,17 @@ SchemaProtocol = TypeVar("SchemaProtocol")
 #  -
 # ---------------------------------------------------------------------------------------
 
-# pylint: disable=redefined-builtin,too-many-branches
-
 
 class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
-    def __init_subclass_with_meta__(  # pylint: disable=arguments-differ
-        cls, _meta=None, default_filter=None, **options
-    ) -> None:
+    def __init_subclass_with_meta__(cls, _meta=None, default_filter=None, **options) -> None:
         if not _meta:
             _meta = BaseNodeOptions(cls)
 
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
-    def get_schema(self) -> Union[NodeSchema, ProfileSchema]:
+    def get_schema(self) -> Union[NodeSchema, ProfileSchema, TemplateSchema]:
         return self._schema
 
     def get_kind(self) -> str:
@@ -130,7 +135,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 labels.append(InfrahubKind.NODE)
             return labels
 
-        if isinstance(self._schema, ProfileSchema):
+        if isinstance(self._schema, ProfileSchema | TemplateSchema):
             labels = [self.get_kind()] + self._schema.inherit_from
             return labels
 
@@ -153,8 +158,8 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return f"{self.get_kind()}(ID: {str(self.id)})"
 
-    def __init__(self, schema: Union[NodeSchema, ProfileSchema], branch: Branch, at: Timestamp):
-        self._schema: Union[NodeSchema, ProfileSchema] = schema
+    def __init__(self, schema: Union[NodeSchema, ProfileSchema, TemplateSchema], branch: Branch, at: Timestamp):
+        self._schema: Union[NodeSchema, ProfileSchema, TemplateSchema] = schema
         self._branch: Branch = branch
         self._at: Timestamp = at
         self._existing: bool = False
@@ -171,12 +176,20 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         # Lists of attributes and relationships names
         self._attributes: list[str] = []
         self._relationships: list[str] = []
+        self._node_changelog: NodeChangelog | None = None
+
+    @property
+    def node_changelog(self) -> NodeChangelog:
+        if self._node_changelog:
+            return self._node_changelog
+
+        raise InitializationError("The node has not been saved so no changelog exists")
 
     @overload
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, str],
+        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str],
         db: InfrahubDatabase,
         branch: Optional[Union[Branch, str]] = ...,
         at: Optional[Union[Timestamp, str]] = ...,
@@ -195,7 +208,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
     async def init(
         cls,
-        schema: Union[NodeSchema, ProfileSchema, str, type[SchemaProtocol]],
+        schema: Union[NodeSchema, ProfileSchema, TemplateSchema, str, type[SchemaProtocol]],
         db: InfrahubDatabase,
         branch: Optional[Union[Branch, str]] = None,
         at: Optional[Union[Timestamp, str]] = None,
@@ -204,15 +217,17 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         branch = await registry.get_branch(branch=branch, db=db)
 
-        if isinstance(schema, (NodeSchema, ProfileSchema)):
+        if isinstance(schema, NodeSchema | ProfileSchema | TemplateSchema):
             attrs["schema"] = schema
         elif isinstance(schema, str):
             # TODO need to raise a proper exception for this, right now it will raise a generic ValueError
             attrs["schema"] = db.schema.get(name=schema, branch=branch)
-        elif hasattr(schema, "_is_runtime_protocol") and getattr(schema, "_is_runtime_protocol"):
+        elif hasattr(schema, "_is_runtime_protocol") and schema._is_runtime_protocol:
             attrs["schema"] = db.schema.get(name=schema.__name__, branch=branch)
         else:
-            raise ValueError(f"Invalid schema provided {type(schema)}, expected NodeSchema or ProfileSchema")
+            raise ValueError(
+                f"Invalid schema provided {type(schema)}, expected NodeSchema, ProfileSchema or TemplateSchema"
+            )
 
         attrs["branch"] = branch
         attrs["at"] = Timestamp(at)
@@ -261,6 +276,56 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
             )
 
+    async def handle_object_template(self, fields: dict, db: InfrahubDatabase, errors: list) -> None:
+        """Fill the `fields` parameters with values from an object template if one is in use."""
+        object_template_field = fields.get(OBJECT_TEMPLATE_RELATIONSHIP_NAME)
+        if not object_template_field:
+            return
+
+        try:
+            template: CoreObjectTemplate = await registry.manager.find_object(
+                db=db,
+                kind=self._schema.get_relationship(name=OBJECT_TEMPLATE_RELATIONSHIP_NAME).peer,
+                id=object_template_field.get("id"),
+                hfid=object_template_field.get("hfid"),
+                branch=self.get_branch_based_on_support_type(),
+            )
+        except NodeNotFoundError:
+            errors.append(
+                ValidationError(
+                    {
+                        f"{OBJECT_TEMPLATE_RELATIONSHIP_NAME}": (
+                            "Unable to find the object template in the database "
+                            f"'{object_template_field.get('id') or object_template_field.get('hfid')}'"
+                        )
+                    }
+                )
+            )
+            return
+
+        # Handle attributes, copy values from template
+        # Relationships handling in performed in GraphQL mutation to create nodes for relationships
+        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}
+
+        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_name == OBJECT_TEMPLATE_RELATIONSHIP_NAME
+            ):
+                continue
+
+            relationship: RelationshipManager = getattr(template, relationship_name)
+            if relationship_schema.cardinality == RelationshipCardinality.ONE:
+                if relationship_peer := await relationship.get_peer(db=db):
+                    fields[relationship_name] = {"id": relationship_peer.id}
+            elif relationship_peers := await relationship.get_peers(db=db):
+                fields[relationship_name] = [{"id": peer_id} for peer_id in relationship_peers]
+
     async def _process_fields(self, fields: dict, db: InfrahubDatabase) -> None:
         errors = []
 
@@ -279,6 +344,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             if field_name not in self._schema.valid_input_names:
                 errors.append(ValidationError({field_name: f"{field_name} is not a valid input for {self.get_kind()}"}))
 
+        # Backfill fields with the ones from the template if there's one
+        await self.handle_object_template(fields=fields, db=db, errors=errors)
+
         # If the object is new, we need to ensure that all mandatory attributes and relationships have been provided
         if not self._existing:
             for mandatory_attr in self._schema.mandatory_attribute_names:
@@ -440,7 +508,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
     async def _generate_relationship_default(
         self,
-        name: str,  # pylint: disable=unused-argument
+        name: str,  # noqa: ARG002
         schema: RelationshipSchema,
         data: Any,
         db: InfrahubDatabase,
@@ -461,7 +529,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         name: str,
         schema: AttributeSchema,
         data: Any,
-        db: InfrahubDatabase,  # pylint: disable=unused-argument
+        db: InfrahubDatabase,  # noqa: ARG002
     ) -> BaseAttribute:
         attr_class = ATTRIBUTE_TYPES[schema.kind].get_infrahub_class()
         attr = attr_class(
@@ -476,10 +544,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         )
         return attr
 
-    async def process_label(self, db: Optional[InfrahubDatabase] = None) -> None:  # pylint: disable=unused-argument
+    async def process_label(self, db: Optional[InfrahubDatabase] = 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
-        # pylint: disable=no-member
         if not self._existing and hasattr(self, "label") and hasattr(self, "name"):
             if self.label.value is None and self.name.value:
                 self.label.value = " ".join([word.title() for word in self.name.value.split("_")])
@@ -526,7 +593,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         await self._process_fields(db=db, fields=kwargs)
         return self
 
-    async def _create(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
+    async def _create(self, db: InfrahubDatabase, at: Timestamp | None = None) -> NodeChangelog:
         create_at = Timestamp(at)
 
         query = await NodeCreateAllQuery.init(db=db, node=self, at=create_at)
@@ -538,44 +605,63 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         self._existing = True
 
         new_ids = query.get_ids()
+        node_changelog = NodeChangelog(node_id=self.get_id(), node_kind=self.get_kind(), display_label="")
 
         # Go over the list of Attribute and assign the new IDs one by one
         for name in self._attributes:
             attr: BaseAttribute = getattr(self, name)
             attr.id, attr.db_id = new_ids[name]
             attr.at = create_at
+            node_changelog.create_attribute(attribute=attr)
 
         # Go over the list of relationships and assign the new IDs one by one
         for name in self._relationships:
             relm: RelationshipManager = getattr(self, name)
             for rel in relm._relationships:
                 identifier = f"{rel.schema.identifier}::{rel.peer_id}"
+
                 rel.id, rel.db_id = new_ids[identifier]
 
+                node_changelog.create_relationship(relationship=rel)
+
+        node_changelog.display_label = await self.render_display_label(db=db)
+        return node_changelog
+
     async def _update(
         self, db: InfrahubDatabase, at: Optional[Timestamp] = None, fields: list[str] | None = None
-    ) -> None:
+    ) -> NodeChangelog:
         """Update the node in the database if needed."""
 
         update_at = Timestamp(at)
+        node_changelog = NodeChangelog(node_id=self.get_id(), node_kind=self.get_kind(), display_label="")
 
         # Go over the list of Attribute and update them one by one
         for name in self._attributes:
-            if fields and name in fields:
-                attr: BaseAttribute = getattr(self, name)
-                await attr.save(at=update_at, db=db)
-            else:
+            if (fields and name in fields) or not fields:
                 attr: BaseAttribute = getattr(self, name)
-                await attr.save(at=update_at, db=db)
+                updated_attribute = await attr.save(at=update_at, db=db)
+                if updated_attribute:
+                    node_changelog.add_attribute(attribute=updated_attribute)
 
         # Go over the list of relationships and update them one by one
+        processed_relationships: list[str] = []
         for name in self._relationships:
-            if fields and name in fields:
+            if (fields and name in fields) or not fields:
+                processed_relationships.append(name)
                 rel: RelationshipManager = getattr(self, name)
-                await rel.save(at=update_at, db=db)
-            else:
-                attr: BaseAttribute = getattr(self, name)
-                await attr.save(at=update_at, db=db)
+                updated_relationship = await rel.save(at=update_at, db=db)
+                node_changelog.add_relationship(relationship=updated_relationship)
+
+        if len(processed_relationships) != len(self._relationships):
+            # Analyze if the node has a parent and add it to the changelog if missing
+            if parent_relationship := self._get_parent_relationship_name():
+                if parent_relationship not in processed_relationships:
+                    rel: RelationshipManager = getattr(self, parent_relationship)
+                    if parent := await rel.get_parent(db=db):
+                        node_changelog.add_parent_from_relationship(parent=parent)
+
+        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:
         """Create or Update the Node in the database."""
@@ -583,10 +669,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         save_at = Timestamp(at)
 
         if self._existing:
-            await self._update(at=save_at, db=db, fields=fields)
+            self._node_changelog = await self._update(at=save_at, db=db, fields=fields)
             return self
 
-        await self._create(at=save_at, db=db)
+        self._node_changelog = await self._create(at=save_at, db=db)
         return self
 
     async def delete(self, db: InfrahubDatabase, at: Optional[Timestamp] = None) -> None:
@@ -594,15 +680,21 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         delete_at = Timestamp(at)
 
+        node_changelog = NodeChangelog(
+            node_id=self.get_id(), node_kind=self.get_kind(), display_label=await self.render_display_label(db=db)
+        )
         # Go over the list of Attribute and update them one by one
         for name in self._attributes:
             attr: BaseAttribute = getattr(self, name)
-            await attr.delete(at=delete_at, db=db)
+            deleted_attribute = await attr.delete(at=delete_at, db=db)
+            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)
-            await rel.delete(at=delete_at, db=db)
+            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
@@ -625,6 +717,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         query = await NodeDeleteQuery.init(db=db, node=self, at=delete_at)
         await query.execute(db=db)
+        self._node_changelog = node_changelog
 
     async def to_graphql(
         self,
@@ -633,6 +726,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         related_node_ids: set | None = None,
         filter_sensitive: bool = False,
         permissions: dict | None = None,
+        include_properties: bool = True,
     ) -> dict:
         """Generate GraphQL Payload for all attributes
 
@@ -686,10 +780,14 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     related_node_ids=related_node_ids,
                     filter_sensitive=filter_sensitive,
                     permissions=permissions,
+                    include_properties=include_properties,
                 )
             else:
                 response[field_name] = await field.to_graphql(
-                    db=db, filter_sensitive=filter_sensitive, permissions=permissions
+                    db=db,
+                    filter_sensitive=filter_sensitive,
+                    permissions=permissions,
+                    include_properties=include_properties,
                 )
 
         for relationship_schema in self.get_schema().relationships:
@@ -731,7 +829,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return changed
 
-    async def render_display_label(self, db: Optional[InfrahubDatabase] = None) -> str:  # pylint: disable=unused-argument
+    async def render_display_label(self, db: Optional[InfrahubDatabase] = None) -> str:  # noqa: ARG002
         if not self._schema.display_labels:
             return repr(self)
 
@@ -757,3 +855,26 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         if not display_label.strip():
             return repr(self)
         return display_label.strip()
+
+    def _get_parent_relationship_name(self) -> str | None:
+        """Return the name of the parent relationship is one is present"""
+        for relationship in self._schema.relationships:
+            if relationship.kind == RelationshipKind.PARENT:
+                return relationship.name
+
+    async def get_object_template(self, db: InfrahubDatabase) -> Node | None:
+        object_template: RelationshipManager = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
+        return await object_template.get_peer(db=db) if object_template is not None else None
+
+    def get_relationships(
+        self, kind: RelationshipKind, exclude: Sequence[str] | None = None
+    ) -> list[RelationshipSchema]:
+        """Return relationships of a given kind with the possiblity to exclude some of them by name."""
+        if exclude is None:
+            exclude = []
+
+        return [
+            relationship
+            for relationship in self.get_schema().relationships
+            if relationship.name not in exclude and relationship.kind == kind
+        ]

infrahub/core/node/base.py

@@ -21,7 +21,7 @@ class BaseOptions:
         if not self._frozen:
             super().__setattr__(name, value)
         else:
-            raise Exception(f"Can't modify frozen Options {self}")  # pylint: disable=broad-exception-raised
+            raise Exception(f"Can't modify frozen Options {self}")
 
     def __repr__(self):
         return f"<{self.__class__.__name__} name={repr(self.name)}>"

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -35,7 +35,7 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name)
 
-    def _build_query_request(
+    async def _build_query_request(
         self,
         updated_node: Node,
         node_schema: MainSchemaTypes,
@@ -51,9 +51,16 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
                 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
@@ -158,7 +165,7 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
     ) -> None:
         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)
-        query_request = self._build_query_request(
+        query_request = await self._build_query_request(
             updated_node=node, node_schema=node_schema, path_groups=path_groups, filters=filters
         )
         if not query_request:

infrahub/core/node/delete_validator.py

@@ -11,7 +11,7 @@ from infrahub.core.query.relationship import (
     RelationshipGetByIdentifierQuery,
     RelationshipPeersData,
 )
-from infrahub.core.schema import MainSchemaTypes, NodeSchema, ProfileSchema
+from infrahub.core.schema import MainSchemaTypes, NodeSchema, ProfileSchema, TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.database import InfrahubDatabase
 from infrahub.exceptions import ValidationError
@@ -28,7 +28,7 @@ class NodeDeleteIndex:
         # {node_schema: {DeleteRelationshipType: {relationship_identifier: peer_node_schema}}}
         self._dependency_graph: dict[str, dict[DeleteRelationshipType, dict[str, set[str]]]] = {}
 
-    def index(self, start_schemas: Iterable[NodeSchema | ProfileSchema]) -> None:
+    def index(self, start_schemas: Iterable[NodeSchema | ProfileSchema | TemplateSchema]) -> None:
         self._index_cascading_deletes(start_schemas=start_schemas)
         self._index_dependent_schema(start_schemas=start_schemas)
 
@@ -50,7 +50,7 @@ class NodeDeleteIndex:
             self._dependency_graph[kind][relationship_type] = defaultdict(set)
         self._dependency_graph[kind][relationship_type][relationship_identifier].update(peer_kinds)
 
-    def _index_cascading_deletes(self, start_schemas: Iterable[NodeSchema | ProfileSchema]) -> None:
+    def _index_cascading_deletes(self, start_schemas: Iterable[NodeSchema | ProfileSchema | TemplateSchema]) -> None:
         kinds_to_check: set[str] = {schema.kind for schema in start_schemas}
         while True:
             try:
@@ -72,7 +72,7 @@ class NodeDeleteIndex:
                     if peer_kind not in self._dependency_graph:
                         kinds_to_check.add(peer_kind)
 
-    def _index_dependent_schema(self, start_schemas: Iterable[NodeSchema | ProfileSchema]) -> None:
+    def _index_dependent_schema(self, start_schemas: Iterable[NodeSchema | ProfileSchema | TemplateSchema]) -> None:
         start_schema_kinds: set[str] = set()
         for start_schema in start_schemas:
             start_schema_kinds.add(start_schema.kind)