Add common_parent relationship attribute (#6626)

This relationship attribute is used to specify that peers of a given
relationship must share a common parent with the source object. While
the parent of the source object is infered automatically (as there is
only one parent per object), the `common_parent` value must be set to
the name of the parent relationship of the peer schema.

Author: gmazoyer

backend/infrahub/core/constraint/node/runner.py

@@ -38,4 +38,6 @@ async def check(
                 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
+                    )

backend/infrahub/core/node/__init__.py

@@ -962,3 +962,12 @@ def validate_relationships(self) -> None:
         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)

backend/infrahub/core/relationship/constraints/count.py

@@ -3,6 +3,7 @@
 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 @@ def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         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 @@ async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -
 
         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 @@ async def check(self, relm: RelationshipManager, node_schema: MainSchemaTypes) -
         # 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",
                 )

backend/infrahub/core/relationship/constraints/interface.py

@@ -1,10 +1,11 @@
 from abc import ABC, abstractmethod
 
+from infrahub.core.node import Node
 from infrahub.core.schema import MainSchemaTypes
 
 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: ...

backend/infrahub/core/relationship/constraints/peer_kind.py

@@ -3,6 +3,7 @@
 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 @@ def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         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):

backend/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
+        )

backend/infrahub/core/relationship/constraints/peer_relatives.py

@@ -58,7 +58,7 @@ async def _check_relationship_peers_relatives(
                     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
 

backend/infrahub/core/relationship/constraints/profiles_kind.py

@@ -23,7 +23,7 @@ def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         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
 

backend/infrahub/core/schema/definitions/internal.py

@@ -754,13 +754,20 @@ def to_dict(self) -> dict[str, Any]:
             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.ALLOWED},
+        ),
         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",

backend/infrahub/core/schema/generated/relationship_schema.py

@@ -73,10 +73,15 @@ class GeneratedRelationshipSchema(HashableModel):
         description="Defines the maximum objects allowed on the other side of the relationship.",
         json_schema_extra={"update": "validate_constraint"},
     )
+    common_parent: str | None = Field(
+        default=None,
+        description="Name of a parent relationship on the peer schema that must share the same related object with the object's parent.",
+        json_schema_extra={"update": "allowed"},
+    )
     common_relatives: list[str] | None = Field(
         default=None,
         description="List of relationship names on the peer schema for which all objects must share the same set of peers.",
-        json_schema_extra={"update": "validate_constraint"},
+        json_schema_extra={"update": "allowed"},
     )
     order_weight: int | None = Field(
         default=None,