infrahub-server 1.1.8__py3-none-any.whl → 1.1.10__py3-none-any.whl

infrahub/config.py

@@ -249,6 +249,12 @@ class DatabaseSettings(BaseSettings):
     retry_limit: int = Field(
         default=3, description="Maximum number of times a transient issue in a transaction should be retried."
     )
+    max_concurrent_queries: int = Field(
+        default=0, ge=0, description="Maximum number of concurrent queries that can run (0 means unlimited)."
+    )
+    max_concurrent_queries_delay: float = Field(
+        default=0.01, ge=0, description="Delay to add when max_concurrent_queries is reached."
+    )
 
     @property
     def database_name(self) -> str:

infrahub/core/diff/query/merge.py

@@ -36,6 +36,7 @@ class DiffMergeQuery(Query):
             "target_branch": self.target_branch.name,
             "source_branch": self.source_branch_name,
         }
+        # ruff: noqa: E501
         query = """
 UNWIND $node_diff_dicts AS node_diff_map
 CALL {
@@ -242,9 +243,11 @@ CALL {
                 CASE
                     WHEN startNode(source_r_rel_2).uuid = r.uuid THEN "r"
                     ELSE "l"
-                END AS r2_dir
+                END AS r2_dir,
+                source_r_rel_1.hierarchy AS r1_hierarchy,
+                source_r_rel_2.hierarchy AS r2_hierarchy
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             CALL {
                 WITH n, rel_name, rel_peer_id, related_rel_status
                 OPTIONAL MATCH (n)
@@ -258,12 +261,12 @@ CALL {
                 SET target_r_rel_1.to = $at
                 SET target_r_rel_2.to = $at
             }
-            WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+            WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
             // ------------------------------
             // conditionally create new IS_RELATED relationships on target_branch, if necessary
             // ------------------------------
             CALL {
-                WITH n, r, r1_dir, r2_dir, rel_name, rel_peer_id, related_rel_status
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, rel_name, rel_peer_id, related_rel_status
                 MATCH (p:Node {uuid: rel_peer_id})
                 OPTIONAL MATCH (n)
                     -[r_rel_1:IS_RELATED {branch: $target_branch, status: related_rel_status}]
@@ -274,42 +277,42 @@ CALL {
                 AND (r_rel_1.to >= $at OR r_rel_1.to IS NULL)
                 AND r_rel_2.from <= $at
                 AND (r_rel_2.to >= $at OR r_rel_2.to IS NULL)
-                WITH n, r, r1_dir, r2_dir, p, related_rel_status, r_rel_1, r_rel_2
+                WITH n, r, r1_dir, r2_dir, r1_hierarchy, r2_hierarchy, p, related_rel_status, r_rel_1, r_rel_2
                 WHERE r_rel_1 IS NULL
                 AND r_rel_2 IS NULL
                 // ------------------------------
                 // create IS_RELATED relationships with directions maintained from source
                 // ------------------------------
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "r"
                     CREATE (n)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         ->(r)
                 }
                 CALL {
-                    WITH n, r, r1_dir, related_rel_status
-                    WITH n, r, r1_dir, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
+                    WITH n, r, r1_dir, r1_hierarchy, related_rel_status
                     WHERE r1_dir = "l"
                     CREATE (n)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r1_hierarchy}]
                         -(r)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "r"
                     CREATE (r)
-                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        -[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         ->(p)
                 }
                 CALL {
-                    WITH r, p, r2_dir, related_rel_status
-                    WITH r, p, r2_dir, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
+                    WITH r, p, r2_dir, r2_hierarchy, related_rel_status
                     WHERE r2_dir = "l"
                     CREATE (r)
-                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status}]
+                        <-[:IS_RELATED {branch: $target_branch, branch_level: $branch_level, from: $at, status: related_rel_status, hierarchy: r2_hierarchy}]
                         -(p)
                 }
             }

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 20
+GRAPH_VERSION = 22

infrahub/core/migrations/__init__.py

@@ -13,6 +13,7 @@ MIGRATION_MAP: dict[str, Optional[type[SchemaMigration]]] = {
     "node.branch.update": None,
     "node.attribute.add": NodeAttributeAddMigration,
     "node.attribute.remove": NodeAttributeRemoveMigration,
+    "node.inherit_from.update": NodeKindUpdateMigration,
     "node.name.update": NodeKindUpdateMigration,
     "node.namespace.update": NodeKindUpdateMigration,
     "node.relationship.remove": PlaceholderDummyMigration,

infrahub/core/migrations/graph/__init__.py

@@ -22,6 +22,8 @@ from .m017_add_core_profile import Migration017
 from .m018_uniqueness_nulls import Migration018
 from .m019_restore_rels_to_time import Migration019
 from .m020_duplicate_edges import Migration020
+from .m021_missing_hierarchy_merge import Migration021
+from .m022_missing_hierarchy_backfill import Migration022
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -49,6 +51,8 @@ MIGRATIONS: list[type[Union[GraphMigration, InternalSchemaMigration, ArbitraryMi
     Migration018,
     Migration019,
     Migration020,
+    Migration021,
+    Migration022,
 ]
 
 

infrahub/core/migrations/graph/m021_missing_hierarchy_merge.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class SetMissingHierarchyQuery(Query):
+    name = "set_missing_hierarchy"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:
+        query = """
+        MATCH (r:Root)
+        WITH r.default_branch AS default_branch
+        MATCH (n:Node)-[main_e:IS_RELATED {branch: default_branch}]-(rel:Relationship)
+        WHERE main_e.hierarchy IS NULL
+        CALL {
+            WITH n, main_e, rel
+            MATCH (n)-[branch_e:IS_RELATED]-(rel)
+            WHERE branch_e.hierarchy IS NOT NULL
+            AND branch_e.branch <> main_e.branch
+            AND branch_e.from < main_e.from
+            SET main_e.hierarchy = branch_e.hierarchy
+        }
+        """
+        self.add_to_query(query)
+
+
+class Migration021(GraphMigration):
+    """
+    A bug in diff merge logic caused the hierarchy information on IS_RELATED edges to be lost when merged into
+    main. This migration sets the missing hierarchy data.
+    """
+
+    name: str = "021_replace_hierarchy"
+    minimum_version: int = 20
+    queries: Sequence[type[Query]] = [SetMissingHierarchyQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:
+        result = MigrationResult()
+        return result

infrahub/core/migrations/graph/m022_missing_hierarchy_backfill.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Sequence
+
+from infrahub.core import registry
+from infrahub.core.initialization import initialization
+from infrahub.core.migrations.shared import GraphMigration, MigrationResult
+from infrahub.lock import initialize_lock
+from infrahub.log import get_logger
+
+from ...query import Query, QueryType
+
+if TYPE_CHECKING:
+    from infrahub.database import InfrahubDatabase
+
+log = get_logger()
+
+
+class BackfillMissingHierarchyQuery(Query):
+    name = "backfill_missing_hierarchy"
+    type = QueryType.WRITE
+    insert_return = False
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        # load schemas from database into registry
+        initialize_lock()
+        await initialization(db=db)
+        kind_hierarchy_map: dict[str, str] = {}
+        schema_branch = await registry.schema.load_schema_from_db(db=db)
+        for node_schema_kind in schema_branch.node_names:
+            node_schema = schema_branch.get_node(name=node_schema_kind, duplicate=False)
+            if node_schema.hierarchy:
+                kind_hierarchy_map[node_schema.kind] = node_schema.hierarchy
+
+        self.params = {"hierarchy_map": kind_hierarchy_map}
+        query = """
+        MATCH (r:Root)
+        WITH r.default_branch AS default_branch
+        MATCH (rel:Relationship {name: "parent__child"})-[e:IS_RELATED]-(n:Node)
+        WHERE e.hierarchy IS NULL
+        WITH DISTINCT rel, n, default_branch
+        CALL {
+            WITH rel, n, default_branch
+            MATCH (rel)-[e:IS_RELATED {branch: default_branch}]-(n)
+            RETURN e
+            ORDER BY e.from DESC
+            LIMIT 1
+        }
+        WITH rel, n, e
+        WHERE e.status = "active" AND e.hierarchy IS NULL
+        SET e.hierarchy = $hierarchy_map[n.kind]
+        """
+        self.add_to_query(query)
+
+
+class Migration022(GraphMigration):
+    """
+    A bug in diff merge logic caused the hierarchy information on IS_RELATED edges to be lost when merged into
+    main. This migration backfills the missing hierarchy data and accounts for the case when the branch that
+    created the data has been deleted.
+    """
+
+    name: str = "022_backfill_hierarchy"
+    minimum_version: int = 21
+    queries: Sequence[type[Query]] = [BackfillMissingHierarchyQuery]
+
+    async def validate_migration(self, db: InfrahubDatabase) -> MigrationResult:  # noqa: ARG002
+        result = MigrationResult()
+        return result

infrahub/core/migrations/query/node_duplicate.py

@@ -9,8 +9,6 @@ from infrahub.core.graph.schema import GraphNodeRelationships, GraphRelDirection
 from infrahub.core.query import Query, QueryType
 
 if TYPE_CHECKING:
-    from pydantic.fields import FieldInfo
-
     from infrahub.database import InfrahubDatabase
 
 
@@ -47,37 +45,37 @@ class NodeDuplicateQuery(Query):
         return query
 
     @staticmethod
-    def _render_sub_query_per_rel_type(
-        rel_name: str,
-        rel_type: str,
-        rel_def: FieldInfo,
-    ) -> str:
+    def _render_sub_query_per_rel_type(rel_name: str, rel_type: str, rel_dir: GraphRelDirection) -> str:
         subquery = [
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f"WITH peer_node, {rel_name}, active_node, new_node",
             f'WHERE type({rel_name}) = "{rel_type}"',
         ]
-        if rel_def.default.direction in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
+        if rel_dir in [GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER]:
             subquery.append(f"""
                 CREATE (new_node)-[new_active_edge:{rel_type} $rel_props_new ]->(peer_node)
                 SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET new_active_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
             subquery.append(f"""
                 CREATE (active_node)-[deleted_edge:{rel_type} $rel_props_prev ]->(peer_node)
                 SET deleted_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET deleted_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
-        elif rel_def.default.direction in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
+        elif rel_dir in [GraphRelDirection.INBOUND, GraphRelDirection.EITHER]:
             subquery.append(f"""
                 CREATE (new_node)<-[new_active_edge:{rel_type} $rel_props_new ]-(peer_node)
                 SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
                 SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET new_active_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
             subquery.append(f"""
                 CREATE (active_node)<-[deleted_edge:{rel_type} $rel_props_prev ]-(peer_node)
-                SET new_active_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
-                SET new_active_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.branch = CASE WHEN {rel_name}.branch = "-global-" THEN "-global-" ELSE $branch END
+                SET deleted_edge.branch_level = CASE WHEN {rel_name}.branch = "-global-" THEN {rel_name}.branch_level ELSE $branch_level END
+                SET deleted_edge.hierarchy = COALESCE({rel_name}.hierarchy, NULL)
                 """)
         subquery.append("RETURN peer_node as p2")
         return "\n".join(subquery)
@@ -86,11 +84,10 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_out(cls) -> str:
         sub_queries_out = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_outband",
-                rel_type=rel_type,
-                rel_def=rel_def,
+                rel_name="rel_outband", rel_type=rel_type, rel_dir=GraphRelDirection.OUTBOUND
             )
-            for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
+            for rel_type, field_info in GraphNodeRelationships.model_fields.items()
+            if field_info.default.direction in (GraphRelDirection.OUTBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_out = "\nUNION\n".join(sub_queries_out)
         return sub_query_out
@@ -99,11 +96,10 @@ class NodeDuplicateQuery(Query):
     def _render_sub_query_in(cls) -> str:
         sub_queries_in = [
             cls._render_sub_query_per_rel_type(
-                rel_name="rel_inband",
-                rel_type=rel_type,
-                rel_def=rel_def,
+                rel_name="rel_inband", rel_type=rel_type, rel_dir=GraphRelDirection.INBOUND
             )
-            for rel_type, rel_def in GraphNodeRelationships.model_fields.items()
+            for rel_type, field_info in GraphNodeRelationships.model_fields.items()
+            if field_info.default.direction in (GraphRelDirection.INBOUND, GraphRelDirection.EITHER)
         ]
         sub_query_in = "\nUNION\n".join(sub_queries_in)
         return sub_query_in
@@ -168,11 +164,12 @@ class NodeDuplicateQuery(Query):
         FOREACH (i in CASE WHEN rel_outband.branch IN ["-global-", $branch] THEN [1] ELSE [] END |
             SET rel_outband.to = $current_time
         )
-        WITH active_node, new_node
+        WITH DISTINCT active_node, new_node
+        // Process Inbound Relationship
         MATCH (active_node)<-[]-(peer)
         CALL {
             WITH active_node, peer
-            MATCH (active_node)-[r]->(peer)
+            MATCH (active_node)<-[r]-(peer)
             WHERE %(branch_filter)s
             RETURN active_node as n1, r as rel_inband1, peer as p1
             ORDER BY r.branch_level DESC, r.from DESC

infrahub/core/models.py

@@ -19,6 +19,8 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
     from infrahub.core.schema.schema_branch import SchemaBranch
 
+GENERIC_ATTRIBUTES_TO_IGNORE = ["namespace", "name", "branch"]
+
 
 class NodeKind(BaseModel):
     namespace: str
@@ -182,6 +184,15 @@ class SchemaUpdateValidationResult(BaseModel):
 
         for schema_name, schema_diff in self.diff.changed.items():
             schema_node = schema.get(name=schema_name, duplicate=False)
+            if "inherit_from" in schema_diff.changed:
+                self.migrations.append(
+                    SchemaUpdateMigrationInfo(
+                        path=SchemaPath(  # type: ignore[call-arg]
+                            schema_kind=schema_name, path_type=SchemaPathType.NODE
+                        ),
+                        migration_name="node.inherit_from.update",
+                    )
+                )
 
             # Nothing to do today if we add a new attribute to a node in the schema
             # for node_field_name, _ in schema_diff.added.items():
@@ -262,6 +273,10 @@ class SchemaUpdateValidationResult(BaseModel):
         field_info = schema.model_fields[node_field_name]
         field_update = str(field_info.json_schema_extra.get("update"))  # type: ignore[union-attr]
 
+        # No need to execute a migration for generic nodes attributes because they are not stored in the database
+        if schema.is_generic_schema and node_field_name in GENERIC_ATTRIBUTES_TO_IGNORE:
+            return
+
         schema_path = SchemaPath(  # type: ignore[call-arg]
             schema_kind=schema.kind,
             path_type=SchemaPathType.NODE,

infrahub/core/query/node.py

@@ -666,18 +666,21 @@ class NodeListGetRelationshipsQuery(Query):
         MATCH paths_in = ((n)<-[r1:IS_RELATED]-(rel:Relationship)<-[r2:IS_RELATED]-(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_in) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "inbound" as direction
         UNION
         MATCH (n:Node) WHERE n.uuid IN $ids
         MATCH paths_out = ((n)-[r1:IS_RELATED]->(rel:Relationship)-[r2:IS_RELATED]->(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_out) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "outbound" as direction
         UNION
         MATCH (n:Node) WHERE n.uuid IN $ids
         MATCH paths_bidir = ((n)-[r1:IS_RELATED]->(rel:Relationship)<-[r2:IS_RELATED]-(peer))
         WHERE ($relationship_identifiers IS NULL OR rel.name in $relationship_identifiers)
         AND all(r IN relationships(paths_bidir) WHERE (%(filters)s))
+        AND n.uuid <> peer.uuid
         RETURN n, rel, peer, r1, r2, "bidirectional" as direction
         """ % {"filters": rels_filter}
 

infrahub/core/validators/interface.py

@@ -1,8 +1,12 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
 
-from infrahub.core.path import GroupedDataPaths
+if TYPE_CHECKING:
+    from infrahub.core.path import GroupedDataPaths
 
-from .model import SchemaConstraintValidatorRequest
+    from .model import SchemaConstraintValidatorRequest
 
 
 class ConstraintCheckerInterface(ABC):

infrahub/core/validators/model.py

@@ -5,6 +5,7 @@ from pydantic import BaseModel, Field
 from infrahub.core.branch import Branch
 from infrahub.core.path import SchemaPath
 from infrahub.core.schema import GenericSchema, NodeSchema
+from infrahub.core.schema.schema_branch import SchemaBranch
 
 
 class SchemaConstraintValidatorRequest(BaseModel):
@@ -12,6 +13,7 @@ class SchemaConstraintValidatorRequest(BaseModel):
     constraint_name: str = Field(..., description="The name of the constraint to validate")
     node_schema: Union[NodeSchema, GenericSchema] = Field(..., description="Schema of Node or Generic to validate")
     schema_path: SchemaPath = Field(..., description="SchemaPath to the element of the schema to validate")
+    schema_branch: SchemaBranch = Field(..., description="SchemaBranch of the element to validate")
 
 
 class SchemaViolation(BaseModel):

infrahub/core/validators/node/hierarchy.py

@@ -7,9 +7,7 @@ from infrahub.core.path import DataPath, GroupedDataPaths
 from infrahub.core.schema import NodeSchema
 
 from ..interface import ConstraintCheckerInterface
-from ..shared import (
-    SchemaValidatorQuery,
-)
+from ..shared import SchemaValidatorQuery
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch

infrahub/core/validators/node/inherit_from.py

@@ -6,7 +6,8 @@ from infrahub_sdk.utils import compare_lists
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
-from infrahub.core.schema import NodeSchema
+from infrahub.core.schema import MainSchemaTypes, NodeSchema
+from infrahub.exceptions import SchemaNotFoundError
 
 from ..interface import ConstraintCheckerInterface
 
@@ -41,8 +42,29 @@ class NodeInheritFromChecker(ConstraintCheckerInterface):
             return grouped_data_paths_list
 
         _, removed, _ = compare_lists(list1=current_schema.inherit_from, list2=request.node_schema.inherit_from)
-
-        if removed:
+        current_inherit_from_ids = {
+            g.id: g.kind
+            for g in [
+                self.db.schema.get(name=n, branch=request.branch, duplicate=False) for n in current_schema.inherit_from
+            ]
+        }
+
+        # Gather IDs for each inherited node in use for candidate schema
+        request_inherited: list[MainSchemaTypes] = []
+        for n in request.node_schema.inherit_from:
+            try:
+                schema = request.schema_branch.get(name=n, duplicate=False)
+            except SchemaNotFoundError:
+                schema = self.db.schema.get(name=n, branch=request.branch, duplicate=False)
+            request_inherited.append(schema)
+        request_inherit_from_ids = {g.id: g.kind for g in request_inherited}
+
+        # Compare IDs to find out if some inherited nodes were removed
+        # Comparing IDs helps us in understanding if a node was renamed or really removed
+        _, removed_ids, _ = compare_lists(
+            list1=list(current_inherit_from_ids.keys()), list2=list(request_inherit_from_ids.keys())
+        )
+        if removed := [current_inherit_from_ids[k] for k in removed_ids]:
             group_data_path.add_data_path(
                 DataPath(
                     branch=str(request.branch.name),

infrahub/core/validators/tasks.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
+
 from infrahub_sdk.batch import InfrahubBatch
 from prefect import flow, task
 from prefect.cache_policies import NONE
@@ -18,6 +20,9 @@ from infrahub.workflows.utils import add_tags
 
 from .models.validate_migration import SchemaValidateMigrationData, SchemaValidatorPathResponseData
 
+if TYPE_CHECKING:
+    from infrahub.core.schema.schema_branch import SchemaBranch
+
 
 @flow(name="schema_validate_migrations", flow_run_name="Validate schema migrations", persist_result=True)
 async def schema_validate_migrations(message: SchemaValidateMigrationData) -> list[SchemaValidatorPathResponseData]:
@@ -41,6 +46,7 @@ async def schema_validate_migrations(message: SchemaValidateMigrationData) -> li
             constraint_name=constraint.constraint_name,
             node_schema=schema,
             schema_path=constraint.path,
+            schema_branch=message.schema_branch,
         )
 
     results = [result async for _, result in batch.execute()]
@@ -59,6 +65,7 @@ async def schema_path_validate(
     constraint_name: str,
     node_schema: NodeSchema | GenericSchema,
     schema_path: SchemaPath,
+    schema_branch: SchemaBranch,
 ) -> SchemaValidatorPathResponseData:
     service = services.service
 
@@ -68,6 +75,7 @@ async def schema_path_validate(
             constraint_name=constraint_name,
             node_schema=node_schema,
             schema_path=schema_path,
+            schema_branch=schema_branch,
         )
 
         component_registry = get_component_registry()

infrahub/core/validators/uniqueness/checker.py

@@ -1,21 +1,16 @@
+from __future__ import annotations
+
 import asyncio
 from itertools import chain
-from typing import Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 
 from infrahub.core import registry
 from infrahub.core.branch import Branch
 from infrahub.core.path import DataPath, GroupedDataPaths
-from infrahub.core.query import QueryResult
-from infrahub.core.schema import (
-    AttributeSchema,
-    MainSchemaTypes,
-    RelationshipSchema,
-)
+from infrahub.core.schema import AttributeSchema, MainSchemaTypes, RelationshipSchema
 from infrahub.core.validators.uniqueness.index import UniquenessQueryResultsIndex
-from infrahub.database import InfrahubDatabase
 
 from ..interface import ConstraintCheckerInterface
-from ..model import SchemaConstraintValidatorRequest
 from .model import (
     NodeUniquenessQueryRequest,
     NonUniqueAttribute,
@@ -26,6 +21,12 @@ from .model import (
 )
 from .query import NodeUniqueAttributeConstraintQuery
 
+if TYPE_CHECKING:
+    from infrahub.core.query import QueryResult
+    from infrahub.database import InfrahubDatabase
+
+    from ..model import SchemaConstraintValidatorRequest
+
 
 def get_attribute_path_from_string(
     path: str, schema: MainSchemaTypes

infrahub/database/__init__.py

@@ -34,7 +34,7 @@ from infrahub.utils import InfrahubStringEnum
 
 from .constants import DatabaseType, Neo4jRuntime
 from .memgraph import DatabaseManagerMemgraph
-from .metrics import QUERY_EXECUTION_METRICS, TRANSACTION_RETRIES
+from .metrics import CONNECTION_POOL_USAGE, QUERY_EXECUTION_METRICS, TRANSACTION_RETRIES
 from .neo4j import DatabaseManagerNeo4j
 
 if TYPE_CHECKING:
@@ -335,6 +335,14 @@ class InfrahubDatabase:
         context: dict[str, str] | None = None,
         type: QueryType | None = None,  # pylint: disable=redefined-builtin
     ) -> tuple[list[Record], dict[str, Any]]:
+        connpool_usage = self._driver._pool.in_use_connection_count(self._driver._pool.address)
+        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
+                await asyncio.sleep(config.SETTINGS.database.max_concurrent_queries_delay)
+                connpool_usage = self._driver._pool.in_use_connection_count(self._driver._pool.address)
+
         with trace.get_tracer(__name__).start_as_current_span("execute_db_query_with_metadata") as span:
             span.set_attribute("query", query)
             if name:

infrahub/database/metrics.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from prometheus_client import Counter, Histogram
+from prometheus_client import Counter, Gauge, Histogram
 
 METRIC_PREFIX = "infrahub_db"
 
@@ -16,3 +16,9 @@ TRANSACTION_RETRIES = Counter(
     "Number of transaction that have been retried due to transcient error",
     labelnames=["name"],
 )
+
+CONNECTION_POOL_USAGE = Gauge(
+    f"{METRIC_PREFIX}_last_connection_pool_usage",
+    "Number of last known active connections in the pool",
+    labelnames=["address"],
+)

infrahub/graphql/initialization.py

@@ -8,6 +8,7 @@ from starlette.background import BackgroundTasks
 from infrahub.core import registry
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError
+from infrahub.graphql.resolvers.many_relationship import ManyRelationshipResolver
 from infrahub.graphql.resolvers.single_relationship import SingleRelationshipResolver
 from infrahub.permissions import PermissionManager
 
@@ -35,6 +36,7 @@ class GraphqlContext:
     branch: Branch
     types: dict
     single_relationship_resolver: SingleRelationshipResolver
+    many_relationship_resolver: ManyRelationshipResolver
     at: Timestamp | None = None
     related_node_ids: set | None = None
     service: InfrahubServices | None = None
@@ -107,6 +109,7 @@ async def prepare_graphql_params(
             db=db,
             branch=branch,
             single_relationship_resolver=SingleRelationshipResolver(),
+            many_relationship_resolver=ManyRelationshipResolver(),
             at=Timestamp(at),
             types=gqlm.get_graphql_types(),
             related_node_ids=set(),