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

infrahub/core/migrations/shared.py

@@ -10,8 +10,7 @@ from infrahub.core.path import SchemaPath  # noqa: TC001
 from infrahub.core.query import Query  # noqa: TC001
 from infrahub.core.schema import (
     AttributeSchema,
-    GenericSchema,
-    NodeSchema,
+    MainSchemaTypes,
     RelationshipSchema,
     SchemaRoot,
     internal_schema,
@@ -43,8 +42,8 @@ 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: 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(
@@ -91,13 +90,13 @@ class SchemaMigration(BaseModel):
         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")

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:
@@ -733,12 +769,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 +800,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 +819,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 +858,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 +901,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 +986,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":
@@ -1001,6 +1089,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 +1112,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/node_property_attribute.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Generic, TypeVar
+
+from infrahub_sdk.template import Jinja2Template
+
+from infrahub.core.query.node import AttributeFromDB
+from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+
+from ..attribute import BaseAttribute, ListAttributeOptional, StringOptional
+
+if TYPE_CHECKING:
+    from infrahub.core.node import Node
+    from infrahub.core.schema import NodeSchema, ProfileSchema, TemplateSchema
+    from infrahub.core.schema.attribute_schema import AttributeSchema
+    from infrahub.core.timestamp import Timestamp
+    from infrahub.database import InfrahubDatabase
+
+T = TypeVar("T")
+
+
+class NodePropertyAttribute(Generic[T]):
+    """A node property attribute is a construct that seats between a property and an attribute.
+
+    View it as a property, set at the node level but stored in the database as an attribute. It usually is something computed from other components of
+    a node, such as its attributes and its relationships.
+    """
+
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: T | None,
+        value: AttributeFromDB | T | None = None,
+    ) -> None:
+        self.node_schema = node_schema
+
+        self.node_attributes: list[str] = []
+        self.node_relationships: list[str] = []
+
+        self.template = template
+        self._value = value
+        self._manually_assigned = False
+
+        self.schema: AttributeSchema
+
+        self.analyze_variables()
+
+    def needs_update(self, fields: list[str] | None) -> bool:
+        """Tell if this node property attribute must be recomputed given a list of updated fields of a node."""
+        if self._manually_assigned or not fields:
+            return True
+        for field in fields:
+            if field in self.node_attributes or field in self.node_relationships:
+                return True
+
+        return False
+
+    @property
+    def attribute_value(self) -> AttributeFromDB | dict[str, T | None]:
+        if isinstance(self._value, AttributeFromDB):
+            return self._value
+        return {"value": self._value}
+
+    def set_value(self, value: T | None, manually_assigned: bool = False) -> None:
+        """Force the value of the node property attribute to the given one."""
+        if isinstance(self._value, AttributeFromDB):
+            self._value.value = value
+        else:
+            self._value = value
+
+        if manually_assigned:
+            self._manually_assigned = True
+
+    def get_value(self, node: Node, at: Timestamp) -> T | None:
+        if isinstance(self._value, AttributeFromDB):
+            attr = self.get_node_attribute(node=node, at=at)
+            return attr.value  # type: ignore
+
+        return self._value
+
+    @abstractmethod
+    def analyze_variables(self) -> None: ...
+
+    @abstractmethod
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None: ...
+
+    @abstractmethod
+    def get_node_attribute(self, node: Node, at: Timestamp) -> BaseAttribute: ...
+
+
+class DisplayLabel(NodePropertyAttribute[str]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: str | None,
+        value: AttributeFromDB | str | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="display_label")
+
+    @property
+    def is_jinja2_template(self) -> bool:
+        if self.template is None:
+            return False
+
+        return any(c in self.template for c in "{}")
+
+    def _analyze_plain_value(self) -> None:
+        if self.template is None or "__" not in self.template:
+            return
+
+        items = self.template.split("__", maxsplit=1)
+        if items[0] not in self.node_schema.attribute_names:
+            raise ValueError(f"{items[0]} is not an attribute of {self.node_schema.kind}")
+
+        self.node_attributes.append(items[0])
+
+    def _analyze_jinja2_value(self) -> None:
+        if self.template is None or not self.is_jinja2_template:
+            return
+
+        tpl = Jinja2Template(template=self.template)
+        for variable in tpl.get_variables():
+            items = variable.split("__", maxsplit=1)
+            if items[0] in self.node_schema.attribute_names:
+                self.node_attributes.append(items[0])
+            elif items[0] in self.node_schema.relationship_names:
+                self.node_relationships.append(items[0])
+            else:
+                raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the display label and record attributes and relationships required to compute it."""
+        if not self.is_jinja2_template:
+            self._analyze_plain_value()
+        else:
+            self._analyze_jinja2_value()
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the display label value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"display_label for schema {self.node_schema.kind} cannot be rendered for node {node.get_schema().kind} {node.id}"
+            )
+
+        if not self.is_jinja2_template:
+            path_value = await node.get_path_value(db=db, path=self.template)
+            # Use .value for enum to keep compat with old style display label
+            self.set_value(value=str(path_value if not isinstance(path_value, Enum) else path_value.value))
+            return
+
+        jinja2_template = Jinja2Template(template=self.template)
+
+        variables: dict[str, Any] = {}
+        for variable in jinja2_template.get_variables():
+            variables[variable] = await node.get_path_value(db=db, path=variable)
+
+        self.set_value(value=await jinja2_template.render(variables=variables))
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> StringOptional:
+        """Return a node attribute that can be stored in the database for this display label and node."""
+        return StringOptional(
+            name="display_label",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )
+
+
+class HumanFriendlyIdentifier(NodePropertyAttribute[list[str]]):
+    def __init__(
+        self,
+        node_schema: NodeSchema | ProfileSchema | TemplateSchema,
+        template: list[str] | None,
+        value: AttributeFromDB | list[str] | None = None,
+    ) -> None:
+        super().__init__(node_schema=node_schema, template=template, value=value)
+
+        self.schema = node_schema.get_attribute(name="human_friendly_id")
+
+    def _analyze_single_variable(self, value: str) -> None:
+        items = value.split("__", maxsplit=1)
+        if items[0] in self.node_schema.attribute_names:
+            self.node_attributes.append(items[0])
+        elif items[0] in self.node_schema.relationship_names:
+            self.node_relationships.append(items[0])
+        else:
+            raise ValueError(f"{items[0]} is neither an attribute or a relationship of {self.node_schema.kind}")
+
+    def analyze_variables(self) -> None:
+        """Look at variables used in the HFID and record attributes and relationships required to compute it."""
+        for item in self.template or []:
+            self._analyze_single_variable(value=item)
+
+    async def compute(self, db: InfrahubDatabase, node: Node) -> None:
+        """Update the HFID value by recomputing it from the template."""
+        if self.template is None or self._manually_assigned:
+            return
+
+        if node.get_schema() != self.node_schema:
+            raise ValueError(
+                f"human_friendly_id for schema {self.node_schema.kind} cannot be computed for node {node.get_schema().kind} {node.id}"
+            )
+
+        value: list[str] = []
+        for path in self.template:
+            path_value = await node.get_path_value(db=db, path=path)
+            # Use .value for enum to be consistent with display label
+            value.append(path_value if not isinstance(path_value, Enum) else path_value.value)
+
+        self.set_value(value=value)
+
+    def get_node_attribute(self, node: Node, at: Timestamp) -> ListAttributeOptional:
+        """Return a node attribute that can be stored in the database for this HFID and node."""
+        return ListAttributeOptional(
+            name="human_friendly_id",
+            schema=self.schema,
+            branch=node.get_branch(),
+            at=at,
+            node=node,
+            data=self.attribute_value,
+        )

infrahub/core/node/standard.py

@@ -111,7 +111,7 @@ class StandardNode(BaseModel):
         node = result.get("n")
 
         self.id = node.element_id
-        self.uuid = node["uuid"]
+        self.uuid = UUID(node["uuid"])
 
         return True
 

infrahub/core/protocols.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from .protocols_base import CoreNode
+from infrahub.core.protocols_base import CoreNode
 
 if TYPE_CHECKING:
     from enum import Enum
@@ -350,6 +350,10 @@ class CoreGeneratorAction(CoreAction):
     generator: RelationshipManager
 
 
+class CoreGeneratorAwareGroup(CoreGroup):
+    pass
+
+
 class CoreGeneratorCheck(CoreCheck):
     instance: String
 
@@ -361,6 +365,8 @@ class CoreGeneratorDefinition(CoreTaskTarget):
     file_path: String
     class_name: String
     convert_query_response: BooleanOptional
+    execute_in_proposed_change: BooleanOptional
+    execute_after_merge: BooleanOptional
     query: RelationshipManager
     repository: RelationshipManager
     targets: RelationshipManager

infrahub/core/query/node.py

@@ -142,9 +142,22 @@ class NodeCreateAllQuery(NodeQuery):
         attributes_ipnetwork: list[AttributeCreateData] = []
         attributes_indexed: list[AttributeCreateData] = []
 
+        if self.node.has_display_label():
+            attributes_indexed.append(
+                self.node._display_label.get_node_attribute(node=self.node, at=at).get_create_data(
+                    node_schema=self.node.get_schema()
+                )
+            )
+        if self.node.has_human_friendly_id():
+            attributes_indexed.append(
+                self.node._human_friendly_id.get_node_attribute(node=self.node, at=at).get_create_data(
+                    node_schema=self.node.get_schema()
+                )
+            )
+
         for attr_name in self.node._attributes:
             attr: BaseAttribute = getattr(self.node, attr_name)
-            attr_data = attr.get_create_data()
+            attr_data = attr.get_create_data(node_schema=self.node.get_schema())
             node_type = attr.get_db_node_type()
 
             if AttributeDBNodeType.IPHOST in node_type:

infrahub/core/registry.py

@@ -113,8 +113,8 @@ class Registry:
             return True
         return False
 
-    def get_node_schema(self, name: str, branch: Branch | str | None = None) -> NodeSchema:
-        return self.schema.get_node_schema(name=name, branch=branch)
+    def get_node_schema(self, name: str, branch: Branch | str | None = None, duplicate: bool = False) -> NodeSchema:
+        return self.schema.get_node_schema(name=name, branch=branch, duplicate=duplicate)
 
     def get_data_type(self, name: str) -> type[InfrahubDataType]:
         if name not in self.data_type:

infrahub/core/relationship/constraints/count.py

@@ -40,7 +40,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         # peer_ids_present_database_only:
         #    relationship to be deleted, need to check if the schema on the other side has a min_count defined
         # TODO see how to manage Generic node
-        peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch)
+        peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch, duplicate=False)
         peer_rels = peer_schema.get_relationships_by_identifier(id=relm.schema.get_identifier())
         if not peer_rels:
             return

infrahub/core/relationship/model.py

@@ -459,7 +459,7 @@ class Relationship(FlagPropertyMixin, NodePropertyMixin):
                 self.set_peer(value=peer)
 
         if not self.peer_id and self.peer_hfid:
-            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch)
+            peer_schema = db.schema.get(name=self.schema.peer, branch=self.branch, duplicate=False)
             kind = (
                 self.data["kind"]
                 if isinstance(self.data, dict) and "kind" in self.data and peer_schema.is_generic_schema