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

infrahub/core/node/lock_utils.py

@@ -1,12 +1,15 @@
 import hashlib
-from typing import Any
+from typing import TYPE_CHECKING
 
-from infrahub.core.branch import Branch
-from infrahub.core.constants.infrahubkind import GENERICGROUP, GRAPHQLQUERYGROUP
+from infrahub.core.node import Node
 from infrahub.core.schema import GenericSchema
 from infrahub.core.schema.schema_branch import SchemaBranch
 
-KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED = [GENERICGROUP]
+if TYPE_CHECKING:
+    from infrahub.core.relationship import RelationshipManager
+
+
+RESOURCE_POOL_LOCK_NAMESPACE = "resource_pool"
 
 
 def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch) -> list[str]:
@@ -43,55 +46,78 @@ def _get_kinds_to_lock_on_object_mutation(kind: str, schema_branch: SchemaBranch
     return kinds
 
 
-def _should_kind_be_locked_on_any_branch(kind: str, schema_branch: SchemaBranch) -> bool:
-    """
-    Check whether kind or any kind generic is in KINDS_TO_LOCK_ON_ANY_BRANCH.
-    """
-
-    if kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-        return True
-
-    node_schema = schema_branch.get(name=kind, duplicate=False)
-    if isinstance(node_schema, GenericSchema):
-        return False
-
-    for generic_kind in node_schema.inherit_from:
-        if generic_kind in KINDS_CONCURRENT_MUTATIONS_NOT_ALLOWED:
-            return True
-    return False
-
-
 def _hash(value: str) -> str:
     # Do not use builtin `hash` for lock names as due to randomization results would differ between
     # different processes.
     return hashlib.sha256(value.encode()).hexdigest()
 
 
-def get_kind_lock_names_on_object_mutation(
-    kind: str, branch: Branch, schema_branch: SchemaBranch, data: dict[str, Any]
-) -> list[str]:
+def get_lock_names_on_object_mutation(node: Node, schema_branch: SchemaBranch) -> list[str]:
     """
-    Return objects kind for which we want to avoid concurrent mutation (create/update). Except for some specific kinds,
-    concurrent mutations are only allowed on non-main branch as objects validations will be performed at least when merging in main branch.
+    Return lock names for object on which we want to avoid concurrent mutation (create/update).
+    Lock names include kind, some generic kinds, resource pool ids, and values of attributes of corresponding uniqueness constraints.
     """
 
-    if not branch.is_default and not _should_kind_be_locked_on_any_branch(kind=kind, schema_branch=schema_branch):
-        return []
-
-    if kind == GRAPHQLQUERYGROUP:
-        # Lock on name as well to improve performances
-        try:
-            name = data["name"].value
-            return [build_object_lock_name(kind + "." + _hash(name))]
-        except KeyError:
-            # We might reach here if we are updating a CoreGraphQLQueryGroup without updating the name,
-            # in which case we would not need to lock. This is not supposed to happen as current `update`
-            # logic first fetches the node with its name.
-            return []
-
-    lock_kinds = _get_kinds_to_lock_on_object_mutation(kind, schema_branch)
-    lock_names = [build_object_lock_name(kind) for kind in lock_kinds]
-    return lock_names
+    lock_names: set[str] = set()
+
+    # Check if node is using resource manager allocation via attributes
+    for attr_name in node.get_schema().attribute_names:
+        attribute = getattr(node, attr_name, None)
+        if attribute is not None and getattr(attribute, "from_pool", None) and "id" in attribute.from_pool:
+            lock_names.add(f"{RESOURCE_POOL_LOCK_NAMESPACE}.{attribute.from_pool['id']}")
+
+    # Check if relationships allocate resources
+    for rel_name in node._relationships:
+        rel_manager: RelationshipManager = getattr(node, rel_name)
+        for rel in rel_manager._relationships:
+            if rel.from_pool and "id" in rel.from_pool:
+                lock_names.add(f"{RESOURCE_POOL_LOCK_NAMESPACE}.{rel.from_pool['id']}")
+
+    lock_kinds = _get_kinds_to_lock_on_object_mutation(node.get_kind(), schema_branch)
+    for kind in lock_kinds:
+        schema = schema_branch.get(name=kind, duplicate=False)
+        ucs = schema.uniqueness_constraints
+        if ucs is None:
+            continue
+
+        ucs_lock_names: list[str] = []
+        uc_attributes_names = set()
+
+        for uc in ucs:
+            uc_attributes_values = []
+            # Keep only attributes constraints
+            for field_path in uc:
+                # Some attributes may exist in different uniqueness constraints, we de-duplicate them
+                if field_path in uc_attributes_names:
+                    continue
+
+                # Exclude relationships uniqueness constraints
+                schema_path = schema.parse_schema_path(path=field_path, schema=schema_branch)
+                if schema_path.related_schema is not None or schema_path.attribute_schema is None:
+                    continue
+
+                uc_attributes_names.add(field_path)
+                attr = getattr(node, schema_path.attribute_schema.name, None)
+                if attr is None or attr.value is None:
+                    # `attr.value` being None corresponds to optional unique attribute.
+                    # `attr` being None is not supposed to happen.
+                    value_hashed = _hash("")
+                else:
+                    value_hashed = _hash(str(attr.value))
+
+                uc_attributes_values.append(value_hashed)
+
+            if uc_attributes_values:
+                uc_lock_name = ".".join(uc_attributes_values)
+                ucs_lock_names.append(uc_lock_name)
+
+        if not ucs_lock_names:
+            continue
+
+        partial_lock_name = kind + "." + ".".join(ucs_lock_names)
+        lock_names.add(build_object_lock_name(partial_lock_name))
+
+    return sorted(lock_names)
 
 
 def build_object_lock_name(name: str) -> str:

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/resource_manager/ip_address_pool.py

@@ -15,6 +15,7 @@ from infrahub.exceptions import PoolExhaustedError, ValidationError
 from infrahub.pools.address import get_available
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -34,7 +35,7 @@ class CoreIPAddressPool(Node):
         prefixlen: int | None = None,
         at: Timestamp | None = None,
     ) -> Node:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # Check if there is already a resource allocated with this identifier
             # if not, pull all existing prefixes and allocated the next available
 

infrahub/core/node/resource_manager/ip_prefix_pool.py

@@ -17,6 +17,7 @@ from infrahub.exceptions import ValidationError
 from infrahub.pools.prefix import get_next_available_prefix
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -37,7 +38,7 @@ class CoreIPPrefixPool(Node):
         prefix_type: str | None = None,
         at: Timestamp | None = None,
     ) -> Node:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # Check if there is already a resource allocated with this identifier
             # if not, pull all existing prefixes and allocated the next available
             if identifier:

infrahub/core/node/resource_manager/number_pool.py

@@ -9,6 +9,7 @@ from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
 from infrahub.exceptions import PoolExhaustedError
 
 from .. import Node
+from ..lock_utils import RESOURCE_POOL_LOCK_NAMESPACE
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
@@ -63,7 +64,7 @@ class CoreNumberPool(Node):
         identifier: str | None = None,
         at: Timestamp | None = None,
     ) -> int:
-        async with lock.registry.get(name=self.get_id(), namespace="resource_pool"):
+        async with lock.registry.get(name=self.get_id(), namespace=RESOURCE_POOL_LOCK_NAMESPACE):
             # NOTE: ideally we should use the HFID as the identifier (if available)
             # one of the challenge with using the HFID is that it might change over time
             # so we need to ensure that the identifier is stable, or we need to handle the case where the identifier changes

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/attribute.py

@@ -184,6 +184,61 @@ class AttributeUpdateNodePropertyQuery(AttributeQuery):
         self.return_labels = ["a", "np", "r"]
 
 
+class AttributeClearNodePropertyQuery(AttributeQuery):
+    name = "attribute_clear_node_property"
+    type: QueryType = QueryType.WRITE
+    insert_return: bool = False
+
+    def __init__(
+        self,
+        prop_name: str,
+        prop_id: str | None = None,
+        **kwargs: Any,
+    ):
+        self.prop_name = prop_name
+        self.prop_id = prop_id
+
+        super().__init__(**kwargs)
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        at = self.at or self.attr.at
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=at)
+        self.params.update(branch_params)
+        self.params["attr_uuid"] = self.attr.id
+        self.params["branch"] = self.branch.name
+        self.params["branch_level"] = self.branch.hierarchy_level
+        self.params["at"] = at.to_string()
+        self.params["prop_name"] = self.prop_name
+        self.params["prop_id"] = self.prop_id
+
+        rel_label = f"HAS_{self.prop_name.upper()}"
+        query = """
+MATCH (a:Attribute { uuid: $attr_uuid })-[r:%(rel_label)s]->(np:Node { uuid: $prop_id })
+WITH DISTINCT a, np
+CALL (a, np) {
+    MATCH (a)-[r:%(rel_label)s]->(np)
+    WHERE %(branch_filter)s
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    LIMIT 1
+    RETURN r AS property_edge
+}
+WITH a, np, property_edge
+WHERE property_edge.status = "active"
+CALL (property_edge) {
+    WITH property_edge
+    WHERE property_edge.branch = $branch
+    SET property_edge.to = $at
+}
+CALL (a, np, property_edge) {
+    WITH property_edge
+    WHERE property_edge.branch_level < $branch_level
+    CREATE (a)-[r:%(rel_label)s { branch: $branch, branch_level: $branch_level, status: "deleted", from: $at }]->(np)
+}
+        """ % {"branch_filter": branch_filter, "rel_label": rel_label}
+        self.add_to_query(query)
+
+
 class AttributeGetQuery(AttributeQuery):
     name = "attribute_get"
     type: QueryType = QueryType.READ

infrahub/core/query/ipam.py

@@ -688,6 +688,7 @@ class IPPrefixReconcileQuery(Query):
             "ip_address_attribute_kind": ADDRESS_ATTRIBUTE_LABEL,
         }
         self.add_to_query(get_new_children_query)
+        self.order_by = ["ip_node.uuid"]
         self.return_labels = ["ip_node", "current_parent", "current_children", "new_parent", "new_children"]
 
     def _get_uuid_from_query(self, node_name: str) -> str | None:

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:
@@ -233,11 +246,15 @@ class NodeCreateAllQuery(NodeQuery):
         ipnetwork_prop_list = [f"{key}: {value}" for key, value in ipnetwork_prop.items()]
 
         attrs_nonindexed_query = """
-        WITH distinct n
+        WITH DISTINCT n
         UNWIND $attrs AS attr
         // Try to find a matching vertex
-        OPTIONAL MATCH (existing_av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
-        WHERE NOT existing_av:AttributeValueIndexed
+        CALL (attr) {
+            OPTIONAL MATCH (existing_av:AttributeValue {value: attr.content.value, is_default: attr.content.is_default})
+            WHERE NOT existing_av:AttributeValueIndexed
+            RETURN existing_av
+            LIMIT 1
+        }
         CALL (attr, existing_av) {
             // If none found, create a new one
             WITH existing_av
@@ -902,6 +919,7 @@ class NodeListGetRelationshipsQuery(Query):
         RETURN DISTINCT n_uuid, rel_name, peer_uuid, direction
         """ % {"filters": rels_filter}
         self.add_to_query(query)
+        self.order_by = ["n_uuid", "rel_name", "peer_uuid", "direction"]
         self.return_labels = ["n_uuid", "rel_name", "peer_uuid", "direction"]
 
     def get_peers_group_by_node(self) -> GroupedPeerNodes:
@@ -971,6 +989,7 @@ class NodeListGetInfoQuery(Query):
         )
         self.params.update(branch_params)
         self.params["ids"] = self.ids
+        self.order_by = ["n.uuid"]
 
         query = """
         MATCH p = (root:Root)<-[:IS_PART_OF]-(n:Node)

infrahub/core/query/relationship.py

@@ -1036,6 +1036,7 @@ class RelationshipCountPerNodeQuery(Query):
         """ % {"branch_filter": branch_filter, "path": path}
 
         self.add_to_query(query)
+        self.order_by = ["peer_node.uuid"]
         self.return_labels = ["peer_node.uuid", "COUNT(peer_node.uuid) as nbr_peers"]
 
     async def get_count_per_peer(self) -> dict[str, int]:

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