infrahub-server 1.3.0b5__py3-none-any.whl → 1.3.0b6__py3-none-any.whl

infrahub/actions/constants.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
+from typing import Self
 
 from infrahub.core.constants import InfrahubKind
 from infrahub.core.schema.dropdown import DropdownChoice
@@ -9,165 +10,121 @@ from infrahub.utils import InfrahubStringEnum
 
 class NodeAction(InfrahubStringEnum):
     CREATED = "created"
-    DELETED = "deleted"
     UPDATED = "updated"
 
 
-class BranchScope(Enum):
+class DropdownEnum(Enum):
+    @classmethod
+    def available_types(cls) -> list[DropdownChoice]:
+        return [cls.__members__[member].value for member in list(cls.__members__)]
+
+    @classmethod
+    def from_value(cls, value: str) -> Self:
+        for member in cls.__members__:
+            if value == cls.__members__[member].value.name:
+                return cls.__members__[member]
+
+        raise NotImplementedError(f"The defined value {value} doesn't match a value of {cls.__class__.__name__}")
+
+
+class BranchScope(DropdownEnum):
     ALL_BRANCHES = DropdownChoice(
         name="all_branches",
         label="All Branches",
         description="All branches",
-        color="#fef08a",
+        color="#4cd964",
     )
     DEFAULT_BRANCH = DropdownChoice(
         name="default_branch",
         label="Default Branch",
         description="Only the default branch",
-        color="#86efac",
+        color="#5ac8fa",
     )
     OTHER_BRANCHES = DropdownChoice(
         name="other_branches",
         label="Other Branches",
         description="All branches except the default branch",
-        color="#e5e7eb",
+        color="#ff2d55",
     )
 
-    @classmethod
-    def available_types(cls) -> list[DropdownChoice]:
-        return [cls.__members__[member].value for member in list(cls.__members__)]
 
-    @classmethod
-    def from_value(cls, value: str) -> BranchScope:
-        for member in cls.__members__:
-            if value == cls.__members__[member].value.name:
-                return cls.__members__[member]
-
-        raise NotImplementedError(f"The defined value {value} doesn't match a branch scope")
-
-
-class MemberAction(Enum):
+class MemberAction(DropdownEnum):
     ADD_MEMBER = DropdownChoice(
         name="add_member",
         label="Add member",
         description="Add impacted member to the selected group",
-        color="#86efac",
+        color="#4cd964",
     )
     REMOVE_MEMBER = DropdownChoice(
         name="remove_member",
         label="Remove member",
         description="Remove impacted member from the selected group",
-        color="#fef08a",
+        color="#ff2d55",
     )
 
-    @classmethod
-    def available_types(cls) -> list[DropdownChoice]:
-        return [cls.__members__[member].value for member in list(cls.__members__)]
-
-    @classmethod
-    def from_value(cls, value: str) -> MemberAction:
-        for member in cls.__members__:
-            if value == cls.__members__[member].value.name:
-                return cls.__members__[member]
-
-        raise NotImplementedError(f"The defined value {value} doesn't match a member action")
-
 
-class MemberUpdate(Enum):
+class MemberUpdate(DropdownEnum):
     ADDED = DropdownChoice(
         name="added",
         label="Added",
         description="Trigger when members are added to this group",
-        color="#86efac",
+        color="#4cd964",
     )
     REMOVED = DropdownChoice(
         name="removed",
         label="Removed",
         description="Trigger when members are removed from this group",
-        color="#fef08a",
+        color="#ff2d55",
     )
 
-    @classmethod
-    def available_types(cls) -> list[DropdownChoice]:
-        return [cls.__members__[member].value for member in list(cls.__members__)]
-
-    @classmethod
-    def from_value(cls, value: str) -> MemberUpdate:
-        for member in cls.__members__:
-            if value == cls.__members__[member].value.name:
-                return cls.__members__[member]
 
-        raise NotImplementedError(f"The defined value {value} doesn't match a MemberUpdate")
-
-
-class RelationshipMatch(Enum):
+class RelationshipMatch(DropdownEnum):
     ADDED = DropdownChoice(
         name="added",
         label="Added",
         description="Check if the selected relationship was added",
-        color="#86efac",
+        color="#4cd964",
     )
     REMOVED = DropdownChoice(
         name="removed",
         label="Removed",
         description="Check if the selected relationship was removed",
-        color="#fef08a",
+        color="#ff2d55",
     )
     UPDATED = DropdownChoice(
         name="updated",
         label="Updated",
         description="Check if the selected relationship was updated, added or removed.",
-        color="#e5e7eb",
+        color="#5ac8fa",
     )
 
-    @classmethod
-    def available_types(cls) -> list[DropdownChoice]:
-        return [cls.__members__[member].value for member in list(cls.__members__)]
-
-    @classmethod
-    def from_value(cls, value: str) -> RelationshipMatch:
-        for member in cls.__members__:
-            if value == cls.__members__[member].value.name:
-                return cls.__members__[member]
-
-        raise NotImplementedError(f"The defined value {value} doesn't match a RelationshipMatch")
 
-
-class ValueMatch(Enum):
+class ValueMatch(DropdownEnum):
     VALUE = DropdownChoice(
         name="value",
         label="Value",
         description="Match against the current value",
-        color="#fef08a",
+        color="#4cd964",
     )
     VALUE_PREVIOUS = DropdownChoice(
         name="value_previous",
         label="Value Previous",
         description="Match against the previous value",
-        color="#86efac",
+        color="#ff2d55",
     )
     VALUE_FULL = DropdownChoice(
         name="value_full",
         label="Full value match",
         description="Match against both the current and previous values",
-        color="#e5e7eb",
+        color="#5ac8fa",
     )
 
-    @classmethod
-    def available_types(cls) -> list[DropdownChoice]:
-        return [cls.__members__[member].value for member in list(cls.__members__)]
-
-    @classmethod
-    def from_value(cls, value: str) -> ValueMatch:
-        for member in cls.__members__:
-            if value == cls.__members__[member].value.name:
-                return cls.__members__[member]
-
-        raise NotImplementedError(f"The defined value {value} doesn't match a ValueMatch")
-
 
 NODES_THAT_TRIGGER_ACTION_RULES_SETUP = [
+    InfrahubKind.GENERATORACTION,
     InfrahubKind.GROUPACTION,
     InfrahubKind.GROUPTRIGGERRULE,
     InfrahubKind.NODETRIGGERRULE,
+    InfrahubKind.NODETRIGGERATTRIBUTEMATCH,
+    InfrahubKind.NODETRIGGERRELATIONSHIPMATCH,
 ]

infrahub/actions/schema.py

@@ -271,6 +271,7 @@ core_node_trigger_attribute_match = NodeSchema(
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
     inherit_from=["CoreNodeTriggerMatch"],
+    display_labels=["attribute_name__value"],
     attributes=[
         Attr(
             name="attribute_name",
@@ -319,6 +320,7 @@ core_node_trigger_relationship_match = NodeSchema(
     branch=BranchSupportType.AGNOSTIC,
     generate_profile=False,
     inherit_from=["CoreNodeTriggerMatch"],
+    display_labels=["relationship_name__value", "modification_type__value"],
     attributes=[
         Attr(
             name="relationship_name",

infrahub/core/constraint/node/runner.py

@@ -38,4 +38,6 @@ class NodeConstraintRunner:
                 relationship_manager: RelationshipManager = getattr(node, relationship_name)
                 await relationship_manager.fetch_relationship_ids(db=db, force_refresh=True)
                 for relationship_constraint in self.relationship_manager_constraints:
-                    await relationship_constraint.check(relm=relationship_manager, node_schema=node.get_schema())
+                    await relationship_constraint.check(
+                        relm=relationship_manager, node_schema=node.get_schema(), node=node
+                    )

infrahub/core/convert_object_type/conversion.py

@@ -101,6 +101,8 @@ async def convert_object_type(
         deleted_node_out_rels_peer_ids = await get_out_rels_peers_ids(node=node, db=dbt)
         deleted_node_unidir_rels_peer_ids = await get_unidirectional_rels_peers_ids(node=node, db=dbt, branch=branch)
 
+        # Delete the node, so we delete relationships with peers as well, which might temporarily break cardinality constraints
+        # but they should be restored when creating the new node.
         deleted_nodes = await NodeManager.delete(db=dbt, branch=branch, nodes=[node], cascade_delete=False)
         if len(deleted_nodes) != 1:
             raise ValueError(f"Deleted {len(deleted_nodes)} nodes instead of 1")

infrahub/core/diff/query/delete_query.py

@@ -9,17 +9,21 @@ class EnrichedDiffDeleteQuery(Query):
     type = QueryType.WRITE
     insert_return = False
 
-    def __init__(self, enriched_diff_root_uuids: list[str], **kwargs: Any) -> None:
+    def __init__(self, enriched_diff_root_uuids: list[str] | None = None, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.enriched_diff_root_uuids = enriched_diff_root_uuids
 
     async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
-        self.params = {"diff_root_uuids": self.enriched_diff_root_uuids}
+        diff_filter = ""
+        if self.enriched_diff_root_uuids:
+            self.params = {"diff_root_uuids": self.enriched_diff_root_uuids}
+            diff_filter = "WHERE d_root.uuid IN $diff_root_uuids"
+
         query = """
         MATCH (d_root:DiffRoot)
-        WHERE d_root.uuid IN $diff_root_uuids
+        %(diff_filter)s
         OPTIONAL MATCH (d_root)-[*]->(diff_thing)
         DETACH DELETE diff_thing
         DETACH DELETE d_root
-        """
+        """ % {"diff_filter": diff_filter}
         self.add_to_query(query=query)

infrahub/core/diff/repository/repository.py

@@ -377,6 +377,10 @@ class DiffRepository:
         await query.execute(db=self.db)
         return query.get_summary()
 
+    async def delete_all_diff_roots(self) -> None:
+        query = await EnrichedDiffDeleteQuery.init(db=self.db)
+        await query.execute(db=self.db)
+
     async def delete_diff_roots(self, diff_root_uuids: list[str]) -> None:
         query = await EnrichedDiffDeleteQuery.init(db=self.db, enriched_diff_root_uuids=diff_root_uuids)
         await query.execute(db=self.db)

infrahub/core/migrations/graph/m015_diff_format_update.py

@@ -31,6 +31,5 @@ class Migration015(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()

infrahub/core/migrations/graph/m016_diff_delete_bug_fix.py

@@ -31,6 +31,5 @@ class Migration016(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()

infrahub/core/migrations/graph/m028_delete_diffs.py

@@ -33,6 +33,5 @@ class Migration028(ArbitraryMigration):
         component_registry = get_component_registry()
         diff_repo = await component_registry.get_component(DiffRepository, db=db, branch=default_branch)
 
-        diff_roots = await diff_repo.get_roots_metadata()
-        await diff_repo.delete_diff_roots(diff_root_uuids=[d.uuid for d in diff_roots])
+        await diff_repo.delete_all_diff_roots()
         return MigrationResult()

infrahub/core/node/__init__.py

@@ -7,6 +7,7 @@ from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
 
+from infrahub import lock
 from infrahub.core import registry
 from infrahub.core.changelog.models import NodeChangelog
 from infrahub.core.constants import (
@@ -34,6 +35,7 @@ from infrahub.core.schema import (
 from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
+from infrahub.pools.models import NumberPoolLockDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
@@ -271,7 +273,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             )
         except NodeNotFoundError:
             if number_pool_parameters:
-                number_pool = await self._create_number_pool(
+                number_pool = await self._fetch_or_create_number_pool(
                     db=db, attribute=attribute, number_pool_parameters=number_pool_parameters
                 )
 
@@ -306,35 +308,49 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                 )
             )
 
-    async def _create_number_pool(
+    async def _fetch_or_create_number_pool(
         self, db: InfrahubDatabase, attribute: BaseAttribute, number_pool_parameters: NumberPoolParameters
     ) -> CoreNumberPool:
-        schema = db.schema.get_node_schema(name="CoreNumberPool", duplicate=False)
-
-        pool_node = self._schema.kind
-        schema_attribute = self._schema.get_attribute(attribute.schema.name)
-        if schema_attribute.inherited:
-            for generic_name in self._schema.inherit_from:
-                generic_node = db.schema.get_generic_schema(name=generic_name, duplicate=False)
-                if attribute.schema.name in generic_node.attribute_names:
-                    pool_node = generic_node.kind
-                    break
-
-        number_pool = await Node.init(db=db, schema=schema, branch=self._branch)
-        await number_pool.new(
-            db=db,
-            id=number_pool_parameters.number_pool_id,
-            name=f"{pool_node}.{attribute.schema.name} [{number_pool_parameters.number_pool_id}]",
-            node=pool_node,
-            node_attribute=attribute.schema.name,
-            start_range=number_pool_parameters.start_range,
-            end_range=number_pool_parameters.end_range,
-            pool_type=NumberPoolType.SCHEMA.value,
-        )
-        await number_pool.save(db=db)
+        number_pool_from_db: CoreNumberPool | None = None
+        lock_definition = NumberPoolLockDefinition(pool_id=str(number_pool_parameters.number_pool_id))
+        async with lock.registry.get(
+            name=lock_definition.lock_name, namespace=lock_definition.namespace_name, local=False
+        ):
+            try:
+                number_pool_from_db = await registry.manager.get_one_by_id_or_default_filter(
+                    db=db, id=str(number_pool_parameters.number_pool_id), kind=CoreNumberPool
+                )
+            except NodeNotFoundError:
+                schema = db.schema.get_node_schema(name="CoreNumberPool", duplicate=False)
+
+                pool_node = self._schema.kind
+                schema_attribute = self._schema.get_attribute(attribute.schema.name)
+                if schema_attribute.inherited:
+                    for generic_name in self._schema.inherit_from:
+                        generic_node = db.schema.get_generic_schema(name=generic_name, duplicate=False)
+                        if attribute.schema.name in generic_node.attribute_names:
+                            pool_node = generic_node.kind
+                            break
+
+                number_pool = await Node.init(db=db, schema=schema, branch=self._branch)
+                await number_pool.new(
+                    db=db,
+                    id=number_pool_parameters.number_pool_id,
+                    name=f"{pool_node}.{attribute.schema.name} [{number_pool_parameters.number_pool_id}]",
+                    node=pool_node,
+                    node_attribute=attribute.schema.name,
+                    start_range=number_pool_parameters.start_range,
+                    end_range=number_pool_parameters.end_range,
+                    pool_type=NumberPoolType.SCHEMA.value,
+                )
+                await number_pool.save(db=db)
+
         # Do a lookup of the number pool to get the correct mapped type from the registry
         # without this we don't get access to the .get_resource() method.
-        return await registry.manager.get_one_by_id_or_default_filter(db=db, id=number_pool.id, kind=CoreNumberPool)
+        created_pool: CoreNumberPool = number_pool_from_db or await registry.manager.get_one_by_id_or_default_filter(
+            db=db, id=number_pool.id, kind=CoreNumberPool
+        )
+        return created_pool
 
     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."""
@@ -541,17 +557,21 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     relationship_attribute: RelationshipManager = getattr(
                         self, attribute_path.active_relationship_schema.name
                     )
-                    peer = await relationship_attribute.get_peer(db=db, raise_on_error=True)
-
-                    related_node = await registry.manager.get_one_by_id_or_default_filter(
-                        db=db, id=peer.id, kind=attribute_path.active_relationship_schema.peer, branch=self._branch.name
-                    )
+                    if peer := await relationship_attribute.get_peer(db=db, raise_on_error=False):
+                        related_node = await registry.manager.get_one_by_id_or_default_filter(
+                            db=db,
+                            id=peer.id,
+                            kind=attribute_path.active_relationship_schema.peer,
+                            branch=self._branch.name,
+                        )
 
-                    attribute: BaseAttribute = getattr(
-                        getattr(related_node, attribute_path.active_attribute_schema.name),
-                        attribute_path.active_attribute_property_name,
-                    )
-                    variables[variable] = attribute
+                        attribute: BaseAttribute = getattr(
+                            getattr(related_node, attribute_path.active_attribute_schema.name),
+                            attribute_path.active_attribute_property_name,
+                        )
+                        variables[variable] = attribute
+                    else:
+                        variables[variable] = None
 
                 elif attribute_path.is_type_attribute:
                     attribute = getattr(
@@ -962,3 +982,12 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for name in self._relationships:
             relm: RelationshipManager = getattr(self, name)
             relm.validate()
+
+    async def get_parent_relationship_peer(self, db: InfrahubDatabase, name: str) -> Node | None:
+        """When a node has a parent relationship of a given name, this method returns the peer of that relationship."""
+        relationship = self.get_schema().get_relationship(name=name)
+        if relationship.kind != RelationshipKind.PARENT:
+            raise ValueError(f"Relationship '{name}' is not of kind 'parent'")
+
+        relm: RelationshipManager = getattr(self, name)
+        return await relm.get_peer(db=db)

infrahub/core/path.py

@@ -63,6 +63,20 @@ class DataPath(InfrahubPath):
     peer_id: str | None = Field(default=None, description="")
     value: Any | None = Field(default=None, description="Optional value of the resource")
 
+    def __hash__(self) -> int:
+        return hash(
+            (
+                self.branch,
+                self.path_type,
+                self.node_id,
+                self.kind,
+                self.field_name,
+                self.property_name,
+                self.peer_id,
+                str(self.value),
+            )
+        )
+
     @property
     def resource_type(self) -> PathResourceType:
         return PathResourceType.DATA

infrahub/core/relationship/constraints/count.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.constants import RelationshipCardinality, RelationshipDirection
+from infrahub.core.node import Node
 from infrahub.core.query.relationship import RelationshipCountPerNodeQuery
 from infrahub.core.schema import MainSchemaTypes
 from infrahub.database import InfrahubDatabase
@@ -25,7 +26,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:  # noqa: ARG002
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         branch = await registry.get_branch(db=self.db) if not self.branch else self.branch
 
         # NOTE adding resolve here because we need to retrieve the real ID
@@ -63,7 +64,7 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
 
         query = await RelationshipCountPerNodeQuery.init(
             db=self.db,
-            node_ids=[node.uuid for node in nodes_to_validate],
+            node_ids=[n.uuid for n in nodes_to_validate],
             identifier=relm.schema.identifier,
             direction=relm.schema.direction.neighbor_direction,
             branch=branch,
@@ -74,14 +75,14 @@ class RelationshipCountConstraint(RelationshipManagerConstraintInterface):
         # Need to adjust the number based on what we will add / remove
         #  +1 for max_count
         #  -1 for min_count
-        for node in nodes_to_validate:
-            if node.max_count and count_per_peer[node.uuid] + 1 > node.max_count:
+        for node_to_validate in nodes_to_validate:
+            if node_to_validate.max_count and count_per_peer[node_to_validate.uuid] + 1 > node_to_validate.max_count:
                 raise ValidationError(
-                    f"Node {node.uuid} has {count_per_peer[node.uuid] + 1} peers "
-                    f"for {relm.schema.identifier}, maximum of {node.max_count} allowed",
+                    f"Node {node_to_validate.uuid} has {count_per_peer[node_to_validate.uuid] + 1} peers "
+                    f"for {relm.schema.identifier}, maximum of {node_to_validate.max_count} allowed",
                 )
-            if node.min_count and count_per_peer[node.uuid] - 1 < node.min_count:
+            if node_to_validate.min_count and count_per_peer[node_to_validate.uuid] - 1 < node_to_validate.min_count:
                 raise ValidationError(
-                    f"Node {node.uuid} has {count_per_peer[node.uuid] - 1} peers "
-                    f"for {relm.schema.identifier}, no fewer than {node.min_count} allowed",
+                    f"Node {node_to_validate.uuid} has {count_per_peer[node_to_validate.uuid] - 1} peers "
+                    f"for {relm.schema.identifier}, no fewer than {node_to_validate.min_count} allowed",
                 )

infrahub/core/relationship/constraints/interface.py

@@ -1,5 +1,6 @@
 from abc import ABC, abstractmethod
 
+from infrahub.core.node import Node
 from infrahub.core.schema import MainSchemaTypes
 
 from ..model import RelationshipManager
@@ -7,4 +8,4 @@ from ..model import RelationshipManager
 
 class RelationshipManagerConstraintInterface(ABC):
     @abstractmethod
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None: ...
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None: ...

infrahub/core/relationship/constraints/peer_kind.py

@@ -3,6 +3,7 @@ from dataclasses import dataclass
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.node import Node
 from infrahub.core.query.node import NodeListGetInfoQuery
 from infrahub.core.schema import MainSchemaTypes
 from infrahub.core.schema.generic_schema import GenericSchema
@@ -26,7 +27,7 @@ class RelationshipPeerKindConstraint(RelationshipManagerConstraintInterface):
         self.db = db
         self.branch = branch
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:  # noqa: ARG002
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         branch = await registry.get_branch(db=self.db) if not self.branch else self.branch
         peer_schema = registry.schema.get(name=relm.schema.peer, branch=branch, duplicate=False)
         if isinstance(peer_schema, GenericSchema):

infrahub/core/relationship/constraints/peer_parent.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Mapping
+
+from infrahub.exceptions import ValidationError
+
+from .interface import RelationshipManagerConstraintInterface
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.core.node import Node
+    from infrahub.core.schema import MainSchemaTypes
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import RelationshipManager
+
+
+class RelationshipPeerParentConstraint(RelationshipManagerConstraintInterface):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    async def _check_relationship_peers_parent(
+        self, relm: RelationshipManager, parent_rel_name: str, node: Node, peers: Mapping[str, Node]
+    ) -> None:
+        """Validate that all peers of a given `relm` have the same parent for the given `relationship_name`."""
+        node_parent = await node.get_parent_relationship_peer(db=self.db, name=parent_rel_name)
+        if not node_parent:
+            # If the schema is properly validated we are not expecting this to happen
+            raise ValidationError(f"Node {node.id} ({node.get_kind()}) does not have a parent peer")
+
+        parents: set[str] = {node_parent.id}
+        for peer in peers.values():
+            parent = await peer.get_parent_relationship_peer(db=self.db, name=parent_rel_name)
+            if not parent:
+                # If the schema is properly validated we are not expecting this to happen
+                raise ValidationError(f"Peer {peer.id} ({peer.get_kind()}) does not have a parent peer")
+            parents.add(parent.id)
+
+        if len(parents) != 1:
+            raise ValidationError(
+                f"All the elements of the '{relm.name}' relationship on node {node.id} ({node.get_kind()}) must have the same parent "
+                "as the node"
+            )
+
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
+        if not relm.schema.common_parent:
+            return
+
+        peers = await relm.get_peers(db=self.db)
+        if not peers:
+            return
+
+        await self._check_relationship_peers_parent(
+            relm=relm, parent_rel_name=relm.schema.common_parent, node=node, peers=peers
+        )

infrahub/core/relationship/constraints/peer_relatives.py

@@ -58,7 +58,7 @@ class RelationshipPeerRelativesConstraint(RelationshipManagerConstraintInterface
                     f"for their '{node.schema.kind}.{relationship_name}' relationship"
                 )
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         if relm.schema.cardinality != RelationshipCardinality.MANY or not relm.schema.common_relatives:
             return
 

infrahub/core/relationship/constraints/profiles_kind.py

@@ -23,7 +23,7 @@ class RelationshipProfilesKindConstraint(RelationshipManagerConstraintInterface)
         self.branch = branch
         self.schema_branch = registry.schema.get_schema_branch(branch.name if branch else registry.default_branch)
 
-    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -> None:
+    async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes, node: Node) -> None:  # noqa: ARG002
         if relm.name != "profiles" or not isinstance(node_schema, NodeSchema):
             return
 

infrahub/core/schema/definitions/internal.py

@@ -754,13 +754,20 @@ relationship_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="common_parent",
+            kind="Text",
+            optional=True,
+            description="Name of a parent relationship on the peer schema that must share the same related object with the object's parent.",
+            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+        ),
         SchemaAttribute(
             name="common_relatives",
             kind="List",
             internal_kind=str,
             optional=True,
             description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
-            extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
+            extra={"update": UpdateSupport.ALLOWED},
         ),
         SchemaAttribute(
             name="order_weight",