infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub/core/migrations/shared.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Sequence
+from typing import TYPE_CHECKING, Any, Sequence, TypeAlias
 
 from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Self
@@ -8,17 +8,10 @@ from typing_extensions import Self
 from infrahub.core import registry
 from infrahub.core.path import SchemaPath  # noqa: TC001
 from infrahub.core.query import Query  # noqa: TC001
-from infrahub.core.schema import (
-    AttributeSchema,
-    GenericSchema,
-    NodeSchema,
-    RelationshipSchema,
-    SchemaRoot,
-    internal_schema,
-)
+from infrahub.core.schema import AttributeSchema, MainSchemaTypes, RelationshipSchema, SchemaRoot, internal_schema
 from infrahub.core.timestamp import Timestamp
 
-from .query import MigrationQuery  # noqa: TC001
+from .query import MigrationBaseQuery  # noqa: TC001
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -41,10 +34,12 @@ class MigrationResult(BaseModel):
 class SchemaMigration(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     name: str = Field(..., description="Name of the migration")
-    queries: Sequence[type[MigrationQuery]] = Field(..., description="List of queries to execute for this migration")
+    queries: Sequence[type[MigrationBaseQuery]] = Field(
+        ..., description="List of queries to execute for this migration"
+    )
 
-    new_node_schema: NodeSchema | GenericSchema | None = None
-    previous_node_schema: NodeSchema | GenericSchema | None = None
+    new_node_schema: MainSchemaTypes | None = None
+    previous_node_schema: MainSchemaTypes | None = None
     schema_path: SchemaPath
 
     async def execute_pre_queries(
@@ -66,9 +61,14 @@ class SchemaMigration(BaseModel):
         return result
 
     async def execute_queries(
-        self, db: InfrahubDatabase, result: MigrationResult, branch: Branch, at: Timestamp
+        self,
+        db: InfrahubDatabase,
+        result: MigrationResult,
+        branch: Branch,
+        at: Timestamp,
+        queries: Sequence[type[MigrationBaseQuery]],
     ) -> MigrationResult:
-        for migration_query in self.queries:
+        for migration_query in queries:
             try:
                 query = await migration_query.init(db=db, branch=branch, at=at, migration=self)
                 await query.execute(db=db)
@@ -79,31 +79,40 @@ class SchemaMigration(BaseModel):
 
         return result
 
-    async def execute(self, db: InfrahubDatabase, branch: Branch, at: Timestamp | str | None = None) -> MigrationResult:
+    async def execute(
+        self,
+        db: InfrahubDatabase,
+        branch: Branch,
+        at: Timestamp | str | None = None,
+        queries: Sequence[type[MigrationBaseQuery]] | None = None,
+    ) -> MigrationResult:
         async with db.start_transaction() as ts:
             result = MigrationResult()
             at = Timestamp(at)
 
             await self.execute_pre_queries(db=ts, result=result, branch=branch, at=at)
-            await self.execute_queries(db=ts, result=result, branch=branch, at=at)
+            queries_to_execute = queries or self.queries
+            await self.execute_queries(db=ts, result=result, branch=branch, at=at, queries=queries_to_execute)
             await self.execute_post_queries(db=ts, result=result, branch=branch, at=at)
 
         return result
 
     @property
-    def new_schema(self) -> NodeSchema | GenericSchema:
+    def new_schema(self) -> MainSchemaTypes:
         if self.new_node_schema:
             return self.new_node_schema
         raise ValueError("new_node_schema hasn't been initialized")
 
     @property
-    def previous_schema(self) -> NodeSchema | GenericSchema:
+    def previous_schema(self) -> MainSchemaTypes:
         if self.previous_node_schema:
             return self.previous_node_schema
         raise ValueError("previous_node_schema hasn't been initialized")
 
 
 class AttributeSchemaMigration(SchemaMigration):
+    uuids: list[str] | None = None
+
     @property
     def new_attribute_schema(self) -> AttributeSchema:
         if not self.schema_path.field_name:
@@ -215,3 +224,27 @@ class ArbitraryMigration(BaseModel):
 
     async def execute(self, db: InfrahubDatabase) -> MigrationResult:
         raise NotImplementedError()
+
+
+class MigrationRequiringRebase(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    name: str = Field(..., description="Name of the migration")
+    minimum_version: int = Field(..., description="Minimum version of the graph to execute this migration")
+
+    @classmethod
+    def init(cls, **kwargs: dict[str, Any]) -> Self:
+        return cls(**kwargs)  # type: ignore[arg-type]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:
+        raise NotImplementedError()
+
+    async def execute_against_branch(self, db: InfrahubDatabase, branch: Branch) -> MigrationResult:
+        """Method that will be run against non-default branches, it assumes that the branches have been rebased."""
+        raise NotImplementedError()
+
+    async def execute(self, db: InfrahubDatabase) -> MigrationResult:
+        """Method that will be run against the default branch."""
+        raise NotImplementedError()
+
+
+MigrationTypes: TypeAlias = GraphMigration | InternalSchemaMigration | ArbitraryMigration | MigrationRequiringRebase

infrahub/core/node/__init__.py

@@ -47,6 +47,7 @@ from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
 from .base import BaseNode, BaseNodeMeta, BaseNodeOptions
+from .node_property_attribute import DisplayLabel, HumanFriendlyIdentifier
 
 if TYPE_CHECKING:
     from typing_extensions import Self
@@ -79,6 +80,29 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         _meta.default_filter = default_filter
         super().__init_subclass_with_meta__(_meta=_meta, **options)
 
+    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: Timestamp | None = None
+        self.id: str = None
+        self.db_id: str = None
+
+        self._source: Node | None = None
+        self._owner: Node | None = None
+        self._is_protected: bool = None
+        self._computed_jinja2_attributes: list[str] = []
+
+        self._display_label: DisplayLabel | None = None
+        self._human_friendly_id: HumanFriendlyIdentifier | None = None
+
+        # Lists of attributes and relationships names
+        self._attributes: list[str] = []
+        self._relationships: list[str] = []
+        self._node_changelog: NodeChangelog | None = None
+
     def get_schema(self) -> NonGenericSchemaTypes:
         return self._schema
 
@@ -126,11 +150,14 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         if not self._schema.human_friendly_id:
             return None
 
-        hfid_values = [await self.get_path_value(db=db, path=item) for item in self._schema.human_friendly_id]
+        hfid_values: list[str] | None = None
+        if self._human_friendly_id:
+            hfid_values = self._human_friendly_id.get_value(node=self, at=self._at)
+        if not hfid_values:
+            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
+        return [self.get_kind()] + hfid if include_kind else hfid
 
     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 (__) ."""
@@ -139,6 +166,37 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             return None
         return "__".join(hfid)
 
+    def has_human_friendly_id(self) -> bool:
+        return self._human_friendly_id is not None
+
+    async def add_human_friendly_id(self, db: InfrahubDatabase) -> None:
+        if not self._schema.human_friendly_id or self._human_friendly_id:
+            return
+
+        self._human_friendly_id = HumanFriendlyIdentifier(
+            node_schema=self._schema, template=self._schema.human_friendly_id
+        )
+        await self._human_friendly_id.compute(db=db, node=self)
+
+    async def get_display_label(self, db: InfrahubDatabase) -> str:
+        if self._display_label:
+            if isinstance(self._display_label._value, str):
+                return self._display_label._value
+            if self._display_label._value:
+                return self._display_label._value.value
+
+        return await self.render_display_label(db=db)
+
+    def has_display_label(self) -> bool:
+        return self._display_label is not None
+
+    async def add_display_label(self, db: InfrahubDatabase) -> None:
+        if not self._schema.display_label or self._display_label:
+            return
+
+        self._display_label = DisplayLabel(node_schema=self._schema, template=self._schema.display_label)
+        await self._display_label.compute(db=db, node=self)
+
     async def get_path_value(self, db: InfrahubDatabase, path: str) -> str:
         schema_path = self._schema.parse_schema_path(
             path=path, schema=db.schema.get_schema_branch(name=self._branch.name)
@@ -197,30 +255,8 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return self._branch
 
     def __repr__(self) -> str:
-        if not self._existing:
-            return f"{self.get_kind()}(ID: {str(self.id)})[NEW]"
-
-        return f"{self.get_kind()}(ID: {str(self.id)})"
-
-    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: Timestamp | None = None
-        self.id: str = None
-        self.db_id: str = None
-
-        self._source: Node | None = None
-        self._owner: Node | None = None
-        self._is_protected: bool = None
-        self._computed_jinja2_attributes: list[str] = []
-
-        # Lists of attributes and relationships names
-        self._attributes: list[str] = []
-        self._relationships: list[str] = []
-        self._node_changelog: NodeChangelog | None = None
+        v = f"{self.get_kind()}(ID: {str(self.id)})"
+        return v if self._existing else f"{v}[NEW]"
 
     @property
     def node_changelog(self) -> NodeChangelog:
@@ -278,7 +314,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return cls(**attrs)
 
-    async def handle_pool(self, db: InfrahubDatabase, attribute: BaseAttribute, errors: list) -> None:
+    async def handle_pool(
+        self, db: InfrahubDatabase, attribute: BaseAttribute, errors: list, allocate_resources: bool = True
+    ) -> None:
         """Evaluate if a resource has been requested from a pool and apply the resource
 
         This method only works on number pools, currently Integer is the only type that has the from_pool
@@ -289,7 +327,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             attribute.from_pool = {"id": attribute.schema.parameters.number_pool_id}
             attribute.is_default = False
 
-        if not attribute.from_pool:
+        if not attribute.from_pool or not allocate_resources:
             return
 
         try:
@@ -449,7 +487,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             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:
+    async def _process_fields(self, fields: dict, db: InfrahubDatabase, process_pools: bool = True) -> None:
         errors = []
 
         if "_source" in fields.keys():
@@ -503,7 +541,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         # Generate Attribute and Relationship and assign them
         # -------------------------------------------
         errors.extend(await self._process_fields_relationships(fields=fields, db=db))
-        errors.extend(await self._process_fields_attributes(fields=fields, db=db))
+        errors.extend(await self._process_fields_attributes(fields=fields, db=db, process_pools=process_pools))
 
         if errors:
             raise ValidationError(errors)
@@ -540,7 +578,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return errors
 
-    async def _process_fields_attributes(self, fields: dict, db: InfrahubDatabase) -> list[ValidationError]:
+    async def _process_fields_attributes(
+        self, fields: dict, db: InfrahubDatabase, process_pools: bool
+    ) -> list[ValidationError]:
         errors: list[ValidationError] = []
 
         for attr_schema in self._schema.attributes:
@@ -565,9 +605,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
                 if not self._existing:
                     attribute: BaseAttribute = getattr(self, attr_schema.name)
-                    await self.handle_pool(db=db, attribute=attribute, errors=errors)
+                    await self.handle_pool(db=db, attribute=attribute, errors=errors, allocate_resources=process_pools)
 
-                    attribute.validate(value=attribute.value, name=attribute.name, schema=attribute.schema)
+                    if process_pools or attribute.from_pool is None:
+                        attribute.validate(value=attribute.value, name=attribute.name, schema=attribute.schema)
             except ValidationError as exc:
                 errors.append(exc)
 
@@ -695,7 +736,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: str | None = None, **kwargs: Any) -> Self:
+    async def new(self, db: InfrahubDatabase, id: str | None = None, process_pools: bool = True, **kwargs: Any) -> Self:
         if id and not is_valid_uuid(id):
             raise ValidationError({"id": f"{id} is not a valid UUID"})
         if id:
@@ -705,7 +746,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         self.id = id or str(UUIDT())
 
-        await self._process_fields(db=db, fields=kwargs)
+        await self._process_fields(db=db, fields=kwargs, process_pools=process_pools)
         await self._process_macros(db=db)
 
         return self
@@ -733,12 +774,26 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             )
             self._updated_at = Timestamp(updated_at)
 
+        if not self._schema.is_schema_node:
+            if hfid := kwargs.pop("human_friendly_id", None):
+                self._human_friendly_id = HumanFriendlyIdentifier(
+                    node_schema=self._schema, template=self._schema.human_friendly_id, value=hfid
+                )
+            if display_label := kwargs.pop("display_label", None):
+                self._display_label = DisplayLabel(
+                    node_schema=self._schema, template=self._schema.display_label, value=display_label
+                )
+
         await self._process_fields(db=db, fields=kwargs)
         return self
 
     async def _create(self, db: InfrahubDatabase, at: Timestamp | None = None) -> NodeChangelog:
         create_at = Timestamp(at)
 
+        if not self._schema.is_schema_node:
+            await self.add_human_friendly_id(db=db)
+            await self.add_display_label(db=db)
+
         query = await NodeCreateAllQuery.init(db=db, node=self, at=create_at)
         await query.execute(db=db)
 
@@ -750,6 +805,13 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         new_ids = query.get_ids()
         node_changelog = NodeChangelog(node_id=self.get_id(), node_kind=self.get_kind(), display_label="")
 
+        if self._human_friendly_id:
+            node_changelog.create_attribute(
+                attribute=self._human_friendly_id.get_node_attribute(node=self, at=create_at)
+            )
+        if self._display_label:
+            node_changelog.create_attribute(attribute=self._display_label.get_node_attribute(node=self, at=create_at))
+
         # Go over the list of Attribute and assign the new IDs one by one
         for name in self._attributes:
             attr: BaseAttribute = getattr(self, name)
@@ -762,12 +824,10 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             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)
+        node_changelog.display_label = await self.get_display_label(db=db)
         return node_changelog
 
     async def _update(
@@ -803,19 +863,41 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     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)
+        # Update the HFID if one of its variables is being updated
+        if self._human_friendly_id and (
+            (fields and "human_friendly_id" in fields) or self._human_friendly_id.needs_update(fields=fields)
+        ):
+            await self._human_friendly_id.compute(db=db, node=self)
+            updated_attribute = await self._human_friendly_id.get_node_attribute(node=self, at=update_at).save(
+                at=update_at, db=db
+            )
+            if updated_attribute:
+                node_changelog.add_attribute(attribute=updated_attribute)
+
+        # Update the display label if one of its variables is being updated
+        if self._display_label and (
+            (fields and "display_label" in fields) or self._display_label.needs_update(fields=fields)
+        ):
+            await self._display_label.compute(db=db, node=self)
+            self._display_label.get_node_attribute(node=self, at=update_at).get_create_data(node_schema=self._schema)
+            updated_attribute = await self._display_label.get_node_attribute(node=self, at=update_at).save(
+                at=update_at, db=db
+            )
+            if updated_attribute:
+                node_changelog.add_attribute(attribute=updated_attribute)
+
+        node_changelog.display_label = await self.get_display_label(db=db)
         return node_changelog
 
     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)
 
         if self._existing:
             self._node_changelog = await self._update(at=save_at, db=db, fields=fields)
-            return self
+        else:
+            self._node_changelog = 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: Timestamp | None = None) -> None:
@@ -824,13 +906,24 @@ 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)
+            node_id=self.get_id(), node_kind=self.get_kind(), display_label=await self.get_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)
-            deleted_attribute = await attr.delete(at=delete_at, db=db)
-            if deleted_attribute:
+            if deleted_attribute := await attr.delete(at=delete_at, db=db):
+                node_changelog.add_attribute(attribute=deleted_attribute)
+
+        if self._human_friendly_id:
+            if deleted_attribute := await self._human_friendly_id.get_node_attribute(node=self, at=delete_at).delete(
+                at=delete_at, db=db
+            ):
+                node_changelog.add_attribute(attribute=deleted_attribute)
+
+        if self._display_label:
+            if deleted_attribute := await self._display_label.get_node_attribute(node=self, at=delete_at).delete(
+                at=delete_at, db=db
+            ):
                 node_changelog.add_attribute(attribute=deleted_attribute)
 
         branch = self.get_branch_based_on_support_type()
@@ -898,7 +991,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 continue
 
             if field_name == "display_label":
-                response[field_name] = await self.render_display_label(db=db)
+                response[field_name] = await self.get_display_label(db=db)
                 continue
 
             if field_name == "hfid":
@@ -958,7 +1051,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
 
         return response
 
-    async def from_graphql(self, data: dict, db: InfrahubDatabase) -> bool:
+    async def from_graphql(self, data: dict, db: InfrahubDatabase, process_pools: bool = True) -> bool:
         """Update object from a GraphQL payload."""
 
         changed = False
@@ -966,7 +1059,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for key, value in data.items():
             if key in self._attributes and isinstance(value, dict):
                 attribute = getattr(self, key)
-                changed |= await attribute.from_graphql(data=value, db=db)
+                changed |= await attribute.from_graphql(data=value, db=db, process_pools=process_pools)
 
             if key in self._relationships:
                 rel: RelationshipManager = getattr(self, key)
@@ -1001,6 +1094,20 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             return repr(self)
         return display_label.strip()
 
+    async def set_human_friendly_id(self, value: list[str] | None) -> None:
+        """Set the human friendly ID of this node if one is set. `save()` must be called to commit the change in the database."""
+        if self._human_friendly_id is None:
+            return
+
+        self._human_friendly_id.set_value(value=value, manually_assigned=True)
+
+    async def set_display_label(self, value: str | None) -> None:
+        """Set the display label of this node if one is set. `save()` must be called to commit the change in the database."""
+        if self._display_label is None:
+            return
+
+        self._display_label.set_value(value=value, manually_assigned=True)
+
     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:
@@ -1010,7 +1117,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         return None
 
     async def get_object_template(self, db: InfrahubDatabase) -> CoreObjectTemplate | None:
-        object_template: RelationshipManager = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
+        object_template: RelationshipManager | None = getattr(self, OBJECT_TEMPLATE_RELATIONSHIP_NAME, None)
         return (
             await object_template.get_peer(db=db, peer_type=CoreObjectTemplate) if object_template is not None else None
         )

infrahub/core/node/constraints/attribute_uniqueness.py

@@ -29,7 +29,9 @@ class NodeAttributeUniquenessConstraint(NodeConstraintInterface):
             attr = getattr(node, unique_attr.name)
             if unique_attr.inherited:
                 for generic_parent_schema_name in node_schema.inherit_from:
-                    generic_parent_schema = self.db.schema.get(generic_parent_schema_name, branch=self.branch)
+                    generic_parent_schema = self.db.schema.get(
+                        generic_parent_schema_name, branch=self.branch, duplicate=False
+                    )
                     parent_attr = generic_parent_schema.get_attribute_or_none(unique_attr.name)
                     if parent_attr is None:
                         continue

infrahub/core/node/create.py

@@ -7,7 +7,7 @@ from infrahub.core import registry
 from infrahub.core.constants import RelationshipCardinality, RelationshipKind
 from infrahub.core.constraint.node.runner import NodeConstraintRunner
 from infrahub.core.node import Node
-from infrahub.core.node.lock_utils import get_kind_lock_names_on_object_mutation
+from infrahub.core.node.lock_utils import get_lock_names_on_object_mutation
 from infrahub.core.protocols import CoreObjectTemplate
 from infrahub.core.schema import GenericSchema
 from infrahub.dependencies.registry import get_component_registry
@@ -62,14 +62,25 @@ async def extract_peer_data(
 
     for rel in template_peer.get_schema().relationship_names:
         rel_manager: RelationshipManager = getattr(template_peer, rel)
-        if (
-            rel_manager.schema.kind not in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-            or rel_manager.schema.name not in obj_peer_schema.relationship_names
-        ):
+
+        if rel_manager.schema.name not in obj_peer_schema.relationship_names:
             continue
 
-        if list(await rel_manager.get_peers(db=db)) == [current_template.id]:
+        peers_map = await rel_manager.get_peers(db=db)
+        if rel_manager.schema.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT] and list(
+            peers_map.keys()
+        ) == [current_template.id]:
             obj_peer_data[rel] = {"id": parent_obj.id}
+            continue
+
+        rel_peer_ids = []
+        for peer_id, peer_object in peers_map.items():
+            # deeper templates are handled in the next level of recursion
+            if peer_object.get_schema().is_template_schema:
+                continue
+            rel_peer_ids.append({"id": peer_id})
+
+        obj_peer_data[rel] = rel_peer_ids
 
     return obj_peer_data
 
@@ -160,45 +171,6 @@ async def _do_create_node(
     return obj
 
 
-async def _do_create_node_with_lock(
-    node_class: type[Node],
-    node_constraint_runner: NodeConstraintRunner,
-    db: InfrahubDatabase,
-    schema: NonGenericSchemaTypes,
-    branch: Branch,
-    fields_to_validate: list[str],
-    data: dict[str, Any],
-    at: Timestamp | None = None,
-) -> Node:
-    schema_branch = registry.schema.get_schema_branch(name=branch.name)
-    lock_names = get_kind_lock_names_on_object_mutation(
-        kind=schema.kind, branch=branch, schema_branch=schema_branch, data=dict(data)
-    )
-
-    if lock_names:
-        async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names):
-            return await _do_create_node(
-                node_class=node_class,
-                node_constraint_runner=node_constraint_runner,
-                db=db,
-                schema=schema,
-                branch=branch,
-                fields_to_validate=fields_to_validate,
-                data=data,
-                at=at,
-            )
-    return await _do_create_node(
-        node_class=node_class,
-        node_constraint_runner=node_constraint_runner,
-        db=db,
-        schema=schema,
-        branch=branch,
-        fields_to_validate=fields_to_validate,
-        data=data,
-        at=at,
-    )
-
-
 async def create_node(
     data: dict[str, Any],
     db: InfrahubDatabase,
@@ -212,37 +184,48 @@ async def create_node(
         raise ValueError(f"Node of generic schema `{schema.name=}` can not be instantiated.")
 
     component_registry = get_component_registry()
-    node_constraint_runner = await component_registry.get_component(
-        NodeConstraintRunner, db=db.start_session() if not db.is_transaction else db, branch=branch
-    )
     node_class = Node
     if schema.kind in registry.node:
         node_class = registry.node[schema.kind]
 
     fields_to_validate = list(data)
-    if db.is_transaction:
-        obj = await _do_create_node_with_lock(
-            node_class=node_class,
-            node_constraint_runner=node_constraint_runner,
-            db=db,
-            schema=schema,
-            branch=branch,
-            fields_to_validate=fields_to_validate,
-            data=data,
-            at=at,
-        )
-    else:
-        async with db.start_transaction() as dbt:
-            obj = await _do_create_node_with_lock(
+
+    preview_obj = await node_class.init(db=db, schema=schema, branch=branch)
+    await preview_obj.new(db=db, process_pools=False, **data)
+    schema_branch = db.schema.get_schema_branch(name=branch.name)
+    lock_names = get_lock_names_on_object_mutation(node=preview_obj, schema_branch=schema_branch)
+
+    obj: Node
+    async with InfrahubMultiLock(lock_registry=lock.registry, locks=lock_names, metrics=False):
+        if db.is_transaction:
+            node_constraint_runner = await component_registry.get_component(NodeConstraintRunner, db=db, branch=branch)
+
+            obj = await _do_create_node(
                 node_class=node_class,
                 node_constraint_runner=node_constraint_runner,
-                db=dbt,
+                db=db,
                 schema=schema,
                 branch=branch,
                 fields_to_validate=fields_to_validate,
                 data=data,
                 at=at,
             )
+        else:
+            async with db.start_transaction() as dbt:
+                node_constraint_runner = await component_registry.get_component(
+                    NodeConstraintRunner, db=dbt, branch=branch
+                )
+
+                obj = await _do_create_node(
+                    node_class=node_class,
+                    node_constraint_runner=node_constraint_runner,
+                    db=dbt,
+                    schema=schema,
+                    branch=branch,
+                    fields_to_validate=fields_to_validate,
+                    data=data,
+                    at=at,
+                )
 
     if await get_profile_ids(db=db, obj=obj):
         node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)