infrahub-server 1.3.0a0__py3-none-any.whl → 1.3.0b2__py3-none-any.whl

infrahub/core/schema/schema_branch.py

@@ -5,6 +5,7 @@ import hashlib
 from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
+from uuid import uuid4
 
 from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.template.exceptions import JinjaTemplateError, JinjaTemplateOperationViolationError
@@ -49,6 +50,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
 from infrahub.core.schema.attribute_schema import get_attribute_schema_class_for_kind
 from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
@@ -89,7 +91,7 @@ class SchemaBranch:
             self.templates = data.get("templates", {})
 
     @classmethod
-    def validate(cls, data: Any) -> Self:  # noqa: ARG003
+    def validate(cls, data: Any) -> Self:
         if isinstance(data, cls):
             return data
         if isinstance(data, dict):
@@ -451,7 +453,7 @@ class SchemaBranch:
         if isinstance(node, NodeSchema | ProfileSchema | TemplateSchema):
             return node.generate_fields_for_display_label()
 
-        fields: dict[str, str | None | dict[str, None]] = {}
+        fields: dict[str, str | dict[str, None] | None] = {}
         if isinstance(node, GenericSchema):
             for child_node_name in node.used_by:
                 child_node = self.get(name=child_node_name, duplicate=False)
@@ -518,6 +520,7 @@ class SchemaBranch:
         self.validate_names()
         self.validate_kinds()
         self.validate_computed_attributes()
+        self.validate_attribute_parameters()
         self.validate_default_values()
         self.validate_count_against_cardinality()
         self.validate_identifiers()
@@ -994,6 +997,65 @@ class SchemaBranch:
                     raise ValueError(
                         f"{node.kind}: Relationship {rel.name!r} is referring an invalid peer {rel.peer!r}"
                     ) from None
+                if rel.common_relatives:
+                    peer_schema = self.get(name=rel.peer, duplicate=False)
+                    for common_relatives_rel_name in rel.common_relatives:
+                        if common_relatives_rel_name not in peer_schema.relationship_names:
+                            raise ValueError(
+                                f"{node.kind}: Relationship {rel.name!r} set 'common_relatives' with invalid relationship from '{rel.peer}'"
+                            ) from None
+
+    def validate_attribute_parameters(self) -> None:
+        for name in self.generics.keys():
+            generic_schema = self.get_generic(name=name, duplicate=False)
+            for attribute in generic_schema.attributes:
+                if (
+                    attribute.kind == "NumberPool"
+                    and isinstance(attribute.parameters, NumberPoolParameters)
+                    and not attribute.parameters.number_pool_id
+                ):
+                    attribute.parameters.number_pool_id = str(uuid4())
+
+        for name in self.nodes.keys():
+            node_schema = self.get_node(name=name, duplicate=False)
+            for attribute in node_schema.attributes:
+                if (
+                    attribute.kind == "NumberPool"
+                    and isinstance(attribute.parameters, NumberPoolParameters)
+                    and not attribute.parameters.number_pool_id
+                ):
+                    self._validate_number_pool_parameters(
+                        node_schema=node_schema, attribute=attribute, number_pool_parameters=attribute.parameters
+                    )
+
+    def _validate_number_pool_parameters(
+        self, node_schema: NodeSchema, attribute: AttributeSchema, number_pool_parameters: NumberPoolParameters
+    ) -> None:
+        if attribute.optional:
+            raise ValidationError(f"{node_schema.kind}.{attribute.name} is a NumberPool it can't be optional")
+
+        if not attribute.read_only:
+            raise ValidationError(
+                f"{node_schema.kind}.{attribute.name} is a NumberPool it has to be a read_only attribute"
+            )
+
+        if attribute.inherited:
+            generics_with_attribute = []
+            for generic_name in node_schema.inherit_from:
+                generic_schema = self.get_generic(name=generic_name, duplicate=False)
+                if attribute.name in generic_schema.attribute_names:
+                    generic_attribute = generic_schema.get_attribute(name=attribute.name)
+                    generics_with_attribute.append(generic_schema)
+                    if isinstance(generic_attribute.parameters, NumberPoolParameters):
+                        number_pool_parameters.number_pool_id = generic_attribute.parameters.number_pool_id
+
+            if len(generics_with_attribute) > 1:
+                raise ValidationError(
+                    f"{node_schema.kind}.{attribute.name} is a NumberPool inherited from more than one generic"
+                )
+
+        else:
+            number_pool_parameters.number_pool_id = str(uuid4())
 
     def validate_computed_attributes(self) -> None:
         self.computed_attributes = ComputedAttributes()
@@ -1960,7 +2022,11 @@ class SchemaBranch:
             )
 
             parent_hfid = f"{relationship.name}__template_name__value"
-            if relationship.kind == RelationshipKind.PARENT and parent_hfid not in template_schema.human_friendly_id:
+            if (
+                not isinstance(template_schema, GenericSchema)
+                and relationship.kind == RelationshipKind.PARENT
+                and parent_hfid not in template_schema.human_friendly_id
+            ):
                 template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
@@ -1996,7 +2062,6 @@ class SchemaBranch:
                 include_in_menu=False,
                 display_labels=["template_name__value"],
                 human_friendly_id=["template_name__value"],
-                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
@@ -2015,7 +2080,6 @@ class SchemaBranch:
                 human_friendly_id=["template_name__value"],
                 uniqueness_constraints=[["template_name__value"]],
                 inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-                default_filter="template_name__value",
                 attributes=[template_name_attr],
                 relationships=[
                     RelationshipSchema(

infrahub/core/validators/__init__.py

@@ -1,7 +1,10 @@
+from infrahub.core.validators.attribute.min_max import AttributeNumberChecker
+
 from .attribute.choices import AttributeChoicesChecker
 from .attribute.enum import AttributeEnumChecker
 from .attribute.kind import AttributeKindChecker
 from .attribute.length import AttributeLengthChecker
+from .attribute.number_pool import AttributeNumberPoolChecker
 from .attribute.optional import AttributeOptionalChecker
 from .attribute.regex import AttributeRegexChecker
 from .attribute.unique import AttributeUniquenessChecker
@@ -26,6 +29,11 @@ CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
     "attribute.max_length.update": AttributeLengthChecker,
     ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE.value: AttributeLengthChecker,
     ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE.value: AttributeLengthChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE.value: AttributeNumberChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE: AttributeNumberPoolChecker,
+    ConstraintIdentifier.ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE: AttributeNumberPoolChecker,
     "attribute.unique.update": AttributeUniquenessChecker,
     "attribute.optional.update": AttributeOptionalChecker,
     "attribute.choices.update": AttributeChoicesChecker,

infrahub/core/validators/attribute/choices.py

@@ -42,7 +42,6 @@ class AttributeChoicesUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/enum.py

@@ -41,7 +41,6 @@ class AttributeEnumUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/kind.py

@@ -48,7 +48,6 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value

infrahub/core/validators/attribute/length.py

@@ -40,7 +40,6 @@ class AttributeLengthUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (
             (toInteger($min_length) IS NOT NULL AND size(attribute_value) < toInteger($min_length))

infrahub/core/validators/attribute/min_max.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberAttributeParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_number_validator"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["min_value"] = self.attribute_schema.parameters.min_value
+        self.params["max_value"] = self.attribute_schema.parameters.max_value
+        self.params["excluded_values"] = self.attribute_schema.parameters.get_excluded_single_values()
+        self.params["excluded_ranges"] = self.attribute_schema.parameters.get_excluded_ranges()
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($min_value) IS NOT NULL AND attribute_value < toInteger($min_value))
+            OR (toInteger($max_value) IS NOT NULL AND attribute_value > toInteger($max_value))
+            OR (size($excluded_values) > 0 AND attribute_value IN $excluded_values)
+            OR (size($excluded_ranges) > 0 AND any(range in $excluded_ranges WHERE attribute_value >= range[0] AND attribute_value <= range[1]))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    async def get_paths(self) -> GroupedDataPaths:
+        grouped_data_paths = GroupedDataPaths()
+        for result in self.results:
+            grouped_data_paths.add_data_path(
+                DataPath(
+                    branch=str(result.get("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+        if not request.schema_path.field_name:
+            raise ValueError("field_name is not defined")
+        attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
+        if not isinstance(attribute_schema.parameters, NumberAttributeParameters):
+            raise ValueError("attribute parameters are not a NumberAttributeParameters")
+
+        if (
+            attribute_schema.parameters.min_value is None
+            and attribute_schema.parameters.max_value is None
+            and attribute_schema.parameters.excluded_values is None
+        ):
+            return grouped_data_paths_list
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/number_pool.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from infrahub.core.constants import PathType
+from infrahub.core.path import DataPath, GroupedDataPaths
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.core.validators.enum import ConstraintIdentifier
+
+from ..interface import ConstraintCheckerInterface
+from ..shared import AttributeSchemaValidatorQuery
+
+if TYPE_CHECKING:
+    from infrahub.core.branch import Branch
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
+
+class AttributeNumberPoolUpdateValidatorQuery(AttributeSchemaValidatorQuery):
+    name: str = "attribute_constraints_numberpool_validator"
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        self.params.update(branch_params)
+
+        if not isinstance(self.attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        self.params["attr_name"] = self.attribute_schema.name
+        self.params["start_range"] = self.attribute_schema.parameters.start_range
+        self.params["end_range"] = self.attribute_schema.parameters.end_range
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
+            WHERE all(
+                r in relationships(path)
+                WHERE %(branch_filter)s
+            )
+            RETURN path as full_path, n as node, rv as value_relationship, av.value as attribute_value
+            ORDER BY rv.branch_level DESC, ra.branch_level DESC, rr.branch_level DESC, rv.from DESC, ra.from DESC, rr.from DESC
+            LIMIT 1
+        }
+        WITH full_path, node, attribute_value, value_relationship
+        WHERE all(r in relationships(full_path) WHERE r.status = "active")
+        AND (
+            (toInteger($start_range) IS NOT NULL AND attribute_value < toInteger($start_range))
+            OR (toInteger($end_range) IS NOT NULL AND attribute_value > toInteger($end_range))
+        )
+        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+
+        self.add_to_query(query)
+        self.return_labels = ["node.uuid", "value_relationship", "attribute_value"]
+
+    async def get_paths(self) -> GroupedDataPaths:
+        grouped_data_paths = GroupedDataPaths()
+        for result in self.results:
+            grouped_data_paths.add_data_path(
+                DataPath(
+                    branch=str(result.get("value_relationship").get("branch")),
+                    path_type=PathType.ATTRIBUTE,
+                    node_id=str(result.get("node.uuid")),
+                    field_name=self.attribute_schema.name,
+                    kind=self.node_schema.kind,
+                    value=result.get("attribute_value"),
+                ),
+            )
+
+        return grouped_data_paths
+
+
+class AttributeNumberPoolChecker(ConstraintCheckerInterface):
+    query_classes = [AttributeNumberPoolUpdateValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "attribute.number.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name in (
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE.value,
+            ConstraintIdentifier.ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE.value,
+        )
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+        if not request.schema_path.field_name:
+            raise ValueError("field_name is not defined")
+        attribute_schema = request.node_schema.get_attribute(name=request.schema_path.field_name)
+        if not isinstance(attribute_schema.parameters, NumberPoolParameters):
+            raise ValueError("attribute parameters are not a NumberPoolParameters")
+
+        for query_class in self.query_classes:
+            # TODO add exception handling
+            query = await query_class.init(
+                db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+        return grouped_data_paths_list

infrahub/core/validators/attribute/optional.py

@@ -38,7 +38,6 @@ class AttributeOptionalUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND (attribute_value IS NULL OR attribute_value = $null_value)
         """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
@@ -85,7 +84,6 @@ class AttributeOptionalChecker(ConstraintCheckerInterface):
             return grouped_data_paths_list
 
         for query_class in self.query_classes:
-            # TODO add exception handling
             query = await query_class.init(
                 db=self.db, branch=self.branch, node_schema=request.node_schema, schema_path=request.schema_path
             )

infrahub/core/validators/attribute/regex.py

@@ -39,7 +39,6 @@ class AttributeRegexUpdateValidatorQuery(AttributeSchemaValidatorQuery):
             LIMIT 1
         }
         WITH full_path, node, attribute_value, value_relationship
-        WITH full_path, node, attribute_value, value_relationship
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value <> $null_value
         AND NOT attribute_value =~ $attr_value_regex

infrahub/core/validators/enum.py

@@ -5,3 +5,8 @@ class ConstraintIdentifier(str, Enum):
     ATTRIBUTE_PARAMETERS_REGEX_UPDATE = "attribute.parameters.regex.update"
     ATTRIBUTE_PARAMETERS_MIN_LENGTH_UPDATE = "attribute.parameters.min_length.update"
     ATTRIBUTE_PARAMETERS_MAX_LENGTH_UPDATE = "attribute.parameters.max_length.update"
+    ATTRIBUTE_PARAMETERS_MIN_VALUE_UPDATE = "attribute.parameters.min_value.update"
+    ATTRIBUTE_PARAMETERS_MAX_VALUE_UPDATE = "attribute.parameters.max_value.update"
+    ATTRIBUTE_PARAMETERS_EXCLUDED_VALUES_UPDATE = "attribute.parameters.excluded_values.update"
+    ATTRIBUTE_PARAMETERS_END_RANGE_UPDATE = "attribute.parameters.end_range.update"
+    ATTRIBUTE_PARAMETERS_START_RANGE_UPDATE = "attribute.parameters.start_range.update"

infrahub/core/validators/tasks.py

@@ -9,7 +9,7 @@ from prefect.logging import get_run_logger
 
 from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.path import SchemaPath  # noqa: TC001
-from infrahub.core.schema import GenericSchema, NodeSchema  # noqa: TC001
+from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
 from infrahub.core.validators.model import (
     SchemaConstraintValidatorRequest,

infrahub/database/__init__.py

@@ -39,7 +39,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from infrahub.core.branch import Branch
-    from infrahub.core.schema import MainSchemaTypes, NodeSchema
+    from infrahub.core.schema import GenericSchema, MainSchemaTypes, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
 validated_database = {}
@@ -91,6 +91,15 @@ class DatabaseSchemaManager:
 
         raise ValueError("The selected node is not of type NodeSchema")
 
+    def get_generic_schema(
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
+    ) -> GenericSchema:
+        schema = self.get(name=name, branch=branch, duplicate=duplicate)
+        if schema.is_generic_schema:
+            return schema
+
+        raise ValueError("The selected node is not of type GenericSchema")
+
     def set(self, name: str, schema: MainSchemaTypes, branch: str | None = None) -> int:
         branch_name = get_branch_name(branch=branch)
         if branch_name not in self._db._schemas:
@@ -284,7 +293,7 @@ class InfrahubDatabase:
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
-    ):
+    ) -> None:
         if self._mode == InfrahubDatabaseMode.SESSION:
             return await self._session.close()
 
@@ -330,7 +339,7 @@ class InfrahubDatabase:
         CONNECTION_POOL_USAGE.labels(self._driver._pool.address).set(float(connpool_usage))
 
         if config.SETTINGS.database.max_concurrent_queries:
-            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:  # noqa: ASYNC110
+            while connpool_usage > config.SETTINGS.database.max_concurrent_queries:
                 await asyncio.sleep(config.SETTINGS.database.max_concurrent_queries_delay)
                 connpool_usage = self._driver._pool.in_use_connection_count(self._driver._pool.address)
 
@@ -487,7 +496,10 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         auth=(config.SETTINGS.database.username, config.SETTINGS.database.password),
         encrypted=config.SETTINGS.database.tls_enabled,
         trusted_certificates=trusted_certificates,
-        notifications_disabled_categories=[NotificationDisabledCategory.UNRECOGNIZED],
+        notifications_disabled_categories=[
+            NotificationDisabledCategory.UNRECOGNIZED,
+            NotificationDisabledCategory.DEPRECATION,  # TODO: Remove me with 1.3
+        ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )
 

infrahub/database/validation.py

@@ -0,0 +1,100 @@
+from infrahub.database import InfrahubDatabase
+
+
+async def verify_no_duplicate_relationships(db: InfrahubDatabase) -> None:
+    """
+    Verify that no duplicate active relationships exist at the database level
+    A duplicate is defined as
+    - connecting the same two nodes
+    - having the same identifier
+    - having the same direction (inbound, outbound, bidirectional)
+    - having the same branch
+    A more thorough check that no duplicates exist at any point in time is possible, but more complex
+    """
+    query = """
+MATCH (a:Node)-[e1:IS_RELATED {status: "active"}]-(rel:Relationship)-[e2:IS_RELATED {branch: e1.branch, status: "active"}]-(b:Node)
+WHERE a.uuid <> b.uuid
+AND e1.to IS NULL
+AND e2.to IS NULL
+WITH a, rel.name AS rel_name, b, e1.branch AS branch, CASE
+    WHEN startNode(e1) = a AND startNode(e2) = rel THEN "out"
+    WHEN startNode(e1) = rel AND startNode(e2) = b THEN "in"
+    ELSE "bidir"
+END AS direction, COUNT(*) AS num_duplicates
+WHERE num_duplicates > 1
+RETURN a.uuid AS node_id1, b.uuid AS node_id2, rel_name, branch, direction, num_duplicates
+    """
+    results = await db.execute_query(query=query)
+    for result in results:
+        node_id1 = result.get("node_id1")
+        node_id2 = result.get("node_id2")
+        rel_name = result.get("rel_name")
+        branch = result.get("branch")
+        direction = result.get("direction")
+        num_duplicates = result.get("num_duplicates")
+        raise ValueError(
+            f"{num_duplicates} duplicate relationships ({branch=},{direction=}) between nodes '{node_id1}' and '{node_id2}'"
+            f" with relationship name '{rel_name}'"
+        )
+
+
+async def verify_no_edges_added_after_node_delete(db: InfrahubDatabase) -> None:
+    """
+    Verify that no edges are added to a Node after it is deleted on a given branch
+    """
+    query = """
+// ------------
+// find deleted nodes
+// ------------
+MATCH (n:Node)-[e:IS_PART_OF]->(:Root)
+WHERE e.status = "deleted" OR e.to IS NOT NULL
+WITH DISTINCT n, e.branch AS delete_branch, e.branch_level AS delete_branch_level, CASE
+    WHEN e.status = "deleted" THEN e.from
+    ELSE e.to
+END AS delete_time
+// ------------
+// find the edges added to the deleted node after the delete time
+// ------------
+MATCH (n)-[added_e]-(peer)
+WHERE added_e.from > delete_time
+AND type(added_e) <> "IS_PART_OF"
+// if the node was deleted on a branch (delete_branch_level > 1), and then updated on main/global (added_e.branch_level = 1), we can ignore it
+AND added_e.branch_level >= delete_branch_level
+AND (added_e.branch = delete_branch OR delete_branch_level = 1)
+WITH DISTINCT n, delete_branch, delete_time, added_e, peer AS added_peer
+// ------------
+// get the branched_from for the branch on which the node was deleted
+// ------------
+CALL (added_e) {
+    MATCH (b:Branch {name: added_e.branch})
+    RETURN b.branched_from AS added_e_branched_from
+}
+// ------------
+// account for the following situations, given that the edge update time is after the node delete time
+//  - deleted on main/global, updated on branch
+//    - illegal if the delete is before branch.branched_from
+//  - deleted on branch, updated on branch
+//    - illegal
+// ------------
+WITH n, delete_branch, delete_time, added_e, added_peer
+WHERE delete_branch = added_e.branch
+OR delete_time < added_e_branched_from
+RETURN n.uuid AS n_uuid, delete_branch, delete_time, added_e, added_peer
+    """
+    results = await db.execute_query(query=query)
+    error_messages = []
+    for result in results:
+        n_uuid = result.get("n_uuid")
+        delete_branch = result.get("delete_branch")
+        delete_time = result.get("delete_time")
+        added_e = result.get("added_e")
+        added_e_branch = added_e.get("branch")
+        added_e_from = added_e.get("from")
+        added_peer = result.get("added_peer")
+        message = (
+            f"Node {n_uuid} was deleted on {delete_branch} at {delete_time} but has an {added_e.type} edge added on"
+            f" branch {added_e_branch} at {added_e_from} to {added_peer.element_id}"
+        )
+        error_messages.append(message)
+    if error_messages:
+        raise ValueError(error_messages)

infrahub/dependencies/builder/constraint/grouped/node_runner.py

@@ -4,6 +4,7 @@ from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilder
 from ..node.grouped_uniqueness import NodeGroupedUniquenessConstraintDependency
 from ..relationship_manager.count import RelationshipCountConstraintDependency
 from ..relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 
 
@@ -18,5 +19,6 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],
         )

infrahub/dependencies/builder/constraint/relationship_manager/peer_relatives.py

@@ -0,0 +1,8 @@
+from infrahub.core.relationship.constraints.peer_relatives import RelationshipPeerRelativesConstraint
+from infrahub.dependencies.interface import DependencyBuilder, DependencyBuilderContext
+
+
+class RelationshipPeerRelativesConstraintDependency(DependencyBuilder[RelationshipPeerRelativesConstraint]):
+    @classmethod
+    def build(cls, context: DependencyBuilderContext) -> RelationshipPeerRelativesConstraint:
+        return RelationshipPeerRelativesConstraint(db=context.db, branch=context.branch)

infrahub/dependencies/builder/diff/deserializer.py

@@ -6,5 +6,5 @@ from .parent_node_adder import DiffParentNodeAdderDependency
 
 class DiffDeserializerDependency(DependencyBuilder[EnrichedDiffDeserializer]):
     @classmethod
-    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:  # noqa: ARG003
+    def build(cls, context: DependencyBuilderContext) -> EnrichedDiffDeserializer:
         return EnrichedDiffDeserializer(parent_adder=DiffParentNodeAdderDependency.build(context=context))