infrahub-server 1.2.0b1__py3-none-any.whl → 1.2.1__py3-none-any.whl

infrahub/core/validators/node/generate_profile.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -61,7 +61,7 @@ class NodeGenerateProfileValidatorQuery(SchemaValidatorQuery):
 class NodeGenerateProfileChecker(ConstraintCheckerInterface):
     query_classes = [NodeGenerateProfileValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/node/hierarchy.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 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
@@ -145,7 +143,7 @@ class NodeHierarchyUpdateValidatorQuery(SchemaValidatorQuery):
 class NodeHierarchyChecker(ConstraintCheckerInterface):
     query_classes = [NodeHierarchyUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/node/inherit_from.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 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
 
@@ -18,7 +19,7 @@ if TYPE_CHECKING:
 
 
 class NodeInheritFromChecker(ConstraintCheckerInterface):
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 
@@ -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/node/relationship.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 from ..interface import ConstraintCheckerInterface
 from ..query import NodeNotPresentValidatorQuery
@@ -16,7 +16,7 @@ if TYPE_CHECKING:
 class NodeRelationshipAddChecker(ConstraintCheckerInterface):
     query_classes = [NodeNotPresentValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None):
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None):
         self.db = db
         self.branch = branch
 

infrahub/core/validators/relationship/count.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType, RelationshipCardinality
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -22,8 +22,8 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
 
     def __init__(
         self,
-        min_count_override: Optional[int] = None,
-        max_count_override: Optional[int] = None,
+        min_count_override: int | None = None,
+        max_count_override: int | None = None,
         **kwargs: Any,
     ) -> None:
         self.min_count_override = min_count_override
@@ -150,7 +150,7 @@ class RelationshipCountUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
 class RelationshipCountChecker(ConstraintCheckerInterface):
     query_classes = [RelationshipCountUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/relationship/optional.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -82,7 +82,7 @@ class RelationshipOptionalUpdateValidatorQuery(RelationshipSchemaValidatorQuery)
 class RelationshipOptionalChecker(ConstraintCheckerInterface):
     query_classes = [RelationshipOptionalUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/relationship/peer.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath, GroupedDataPaths
@@ -108,7 +108,7 @@ class RelationshipPeerUpdateValidatorQuery(RelationshipSchemaValidatorQuery):
 class RelationshipPeerChecker(ConstraintCheckerInterface):
     query_classes = [RelationshipPeerUpdateValidatorQuery]
 
-    def __init__(self, db: InfrahubDatabase, branch: Optional[Branch] = None) -> None:
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
         self.db = db
         self.branch = branch
 

infrahub/core/validators/shared.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Union
+from typing import Any
 
 from infrahub.core.path import GroupedDataPaths, SchemaPath  # noqa: TC001
 from infrahub.core.query import Query, QueryType
@@ -12,7 +12,7 @@ class SchemaValidatorQuery(Query):
 
     def __init__(
         self,
-        node_schema: Union[NodeSchema, GenericSchema],
+        node_schema: NodeSchema | GenericSchema,
         schema_path: SchemaPath,
         **kwargs: Any,
     ) -> None:

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(
@@ -43,6 +48,7 @@ async def schema_validate_migrations(
             constraint_name=constraint.constraint_name,
             node_schema=schema,
             schema_path=constraint.path,
+            schema_branch=message.schema_branch,
             service=service,
         )
 
@@ -62,6 +68,7 @@ async def schema_path_validate(
     constraint_name: str,
     node_schema: NodeSchema | GenericSchema,
     schema_path: SchemaPath,
+    schema_branch: SchemaBranch,
     service: InfrahubServices,
 ) -> SchemaValidatorPathResponseData:
     async with service.database.start_session() as db:
@@ -70,6 +77,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
 
 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,10 +21,16 @@ 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
-) -> tuple[Union[AttributeSchema, RelationshipSchema], Optional[str]]:
+) -> tuple[AttributeSchema | RelationshipSchema, str | None]:
     if "__" in path:
         name, property_name = path.split("__")
     else:
@@ -45,7 +46,7 @@ def get_attribute_path_from_string(
 
 class UniquenessChecker(ConstraintCheckerInterface):
     def __init__(
-        self, db: InfrahubDatabase, branch: Optional[Union[Branch, str]] = None, max_concurrent_execution: int = 5
+        self, db: InfrahubDatabase, branch: Branch | str | None = None, max_concurrent_execution: int = 5
     ) -> None:
         self.db = db
         self.branch = branch
@@ -130,22 +131,22 @@ class UniquenessChecker(ConstraintCheckerInterface):
 
         branch = await self.get_branch()
         schema_branch = self.db.schema.get_schema_branch(name=branch.name)
-        path_groups = schema.get_unique_constraint_schema_attribute_paths(
-            include_unique_attributes=True, schema_branch=schema_branch
-        )
-        for constraint_group in path_groups:
+        uniqueness_constraint_paths = schema.get_unique_constraint_schema_attribute_paths(schema_branch=schema_branch)
+        for uniqueness_constraint_path in uniqueness_constraint_paths:
             non_unique_nodes_by_id: dict[str, NonUniqueNode] = {}
             constraint_group_relationship_identifiers = [
                 schema_attribute_path.relationship_schema.get_identifier()
-                for schema_attribute_path in constraint_group
+                for schema_attribute_path in uniqueness_constraint_path.attributes_paths
                 if schema_attribute_path.relationship_schema
             ]
             constraint_group_attribute_names = [
                 schema_attribute_path.attribute_schema.name
-                for schema_attribute_path in constraint_group
+                for schema_attribute_path in uniqueness_constraint_path.attributes_paths
                 if schema_attribute_path.attribute_schema
             ]
-            node_ids_in_violation = results_index.get_node_ids_for_path_group(path_group=constraint_group)
+            node_ids_in_violation = results_index.get_node_ids_for_path_group(
+                path_group=uniqueness_constraint_path.attributes_paths
+            )
             for result in query_results:
                 node_id = str(result.get("node_id"))
                 if node_id not in node_ids_in_violation:
@@ -189,14 +190,14 @@ class UniquenessChecker(ConstraintCheckerInterface):
 
     def get_uniqueness_violations(
         self, non_unique_node: NonUniqueNode
-    ) -> set[Union[NonUniqueAttribute, NonUniqueRelatedAttribute]]:
-        constraint_violations: set[Union[NonUniqueAttribute, NonUniqueRelatedAttribute]] = set()
+    ) -> set[NonUniqueAttribute | NonUniqueRelatedAttribute]:
+        constraint_violations: set[NonUniqueAttribute | NonUniqueRelatedAttribute] = set()
         for attribute_schema in non_unique_node.node_schema.unique_attributes:
             violation = non_unique_node.get_attribute_violation(attribute_schema.name)
             if violation:
                 constraint_violations.add(violation)
         for uniqueness_constraint in non_unique_node.node_schema.uniqueness_constraints or []:
-            constraint_spec: list[tuple[Union[AttributeSchema, RelationshipSchema], Optional[str]]] = []
+            constraint_spec: list[tuple[AttributeSchema | RelationshipSchema, str | None]] = []
             for element in uniqueness_constraint:
                 sub_schema, property_name = get_attribute_path_from_string(element, non_unique_node.node_schema)
                 constraint_spec.append((sub_schema, property_name))

infrahub/core/validators/uniqueness/index.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from typing import TYPE_CHECKING, Any, Iterable, Optional
+from typing import TYPE_CHECKING, Any, Iterable
 
 if TYPE_CHECKING:
     from infrahub.core.query import QueryResult
@@ -29,7 +29,7 @@ class GroupedIndexKey:
 
 
 class UniquenessQueryResultsIndex:
-    def __init__(self, query_results: Iterable[QueryResult], exclude_node_ids: Optional[set[str]] = None) -> None:
+    def __init__(self, query_results: Iterable[QueryResult], exclude_node_ids: set[str] | None = None) -> None:
         self._relationship_index: dict[str, dict[str, set[str]]] = {}
         self._attribute_index: dict[str, dict[Any, set[str]]] = {}
         self._node_index: dict[str, dict[str, Any]] = {}

infrahub/core/validators/uniqueness/model.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional, Union
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -8,8 +8,8 @@ from infrahub.core.schema import AttributeSchema, MainSchemaTypes, RelationshipS
 
 class QueryRelationshipAttributePath(BaseModel):
     identifier: str
-    attribute_name: Optional[str] = Field(default=None)
-    value: Optional[Any] = Field(default=None)
+    attribute_name: str | None = Field(default=None)
+    value: Any | None = Field(default=None)
 
     def __hash__(self) -> int:
         to_hash = self.identifier
@@ -22,8 +22,8 @@ class QueryRelationshipAttributePath(BaseModel):
 
 class QueryAttributePath(BaseModel):
     attribute_name: str
-    property_name: Optional[str] = Field(default=None)
-    value: Optional[Any] = Field(default=None)
+    property_name: str | None = Field(default=None)
+    value: Any | None = Field(default=None)
 
     def __hash__(self) -> int:
         to_hash = self.attribute_name
@@ -118,8 +118,8 @@ class NonUniqueNode(BaseModel):
     non_unique_related_attributes: list[NonUniqueRelatedAttribute] = Field(default_factory=list)
 
     def get_relationship_violation(
-        self, relationship_name: str, attribute_name: Optional[str]
-    ) -> Optional[NonUniqueRelatedAttribute]:
+        self, relationship_name: str, attribute_name: str | None
+    ) -> NonUniqueRelatedAttribute | None:
         attribute_names = {attribute_name}
         if attribute_name is None:
             attribute_names.add("id")
@@ -128,16 +128,16 @@ class NonUniqueNode(BaseModel):
                 return nura
         return None
 
-    def get_attribute_violation(self, attribute_name: str) -> Optional[NonUniqueAttribute]:
+    def get_attribute_violation(self, attribute_name: str) -> NonUniqueAttribute | None:
         for nua in self.non_unique_attributes:
             if nua.attribute_name == attribute_name:
                 return nua
         return None
 
     def get_constraint_violation(
-        self, constraint_specifications: list[tuple[Union[AttributeSchema, RelationshipSchema], Optional[str]]]
-    ) -> Optional[list[Union[NonUniqueAttribute, NonUniqueRelatedAttribute]]]:
-        violations: list[Union[NonUniqueAttribute, NonUniqueRelatedAttribute]] = []
+        self, constraint_specifications: list[tuple[AttributeSchema | RelationshipSchema, str | None]]
+    ) -> list[NonUniqueAttribute | NonUniqueRelatedAttribute] | None:
+        violations: list[NonUniqueAttribute | NonUniqueRelatedAttribute] = []
         for sub_schema, property_name in constraint_specifications:
             if isinstance(sub_schema, AttributeSchema):
                 attribute_violation = self.get_attribute_violation(sub_schema.name)

infrahub/database/__init__.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import asyncio
 import random
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable, Coroutine, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, TypeVar
 
 from neo4j import (
     READ_ACCESS,
@@ -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:
@@ -69,7 +69,7 @@ class InfrahubDatabaseSessionMode(InfrahubStringEnum):
     WRITE = "write"
 
 
-def get_branch_name(branch: Optional[Union[Branch, str]] = None) -> str:
+def get_branch_name(branch: Branch | str | None = None) -> str:
     if not branch:
         return registry.default_branch
     if isinstance(branch, str):
@@ -82,43 +82,39 @@ class DatabaseSchemaManager:
     def __init__(self, db: InfrahubDatabase) -> None:
         self._db = db
 
-    def get(self, name: str, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True) -> MainSchemaTypes:
+    def get(self, name: str, branch: Branch | str | None = None, duplicate: bool = True) -> MainSchemaTypes:
         branch_name = get_branch_name(branch=branch)
         if branch_name not in self._db._schemas:
             return registry.schema.get(name=name, branch=branch, duplicate=duplicate)
         return self._db._schemas[branch_name].get(name=name, duplicate=duplicate)
 
-    def get_node_schema(
-        self, name: str, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
-    ) -> NodeSchema:
+    def get_node_schema(self, name: str, branch: Branch | str | None = None, duplicate: bool = True) -> NodeSchema:
         schema = self.get(name=name, branch=branch, duplicate=duplicate)
         if schema.is_node_schema:
             return schema
 
         raise ValueError("The selected node is not of type NodeSchema")
 
-    def set(self, name: str, schema: MainSchemaTypes, branch: Optional[str] = None) -> int:
+    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:
             return registry.schema.set(name=name, schema=schema, branch=branch)
         return self._db._schemas[branch_name].set(name=name, schema=schema)
 
-    def has(self, name: str, branch: Optional[Union[Branch, str]] = None) -> bool:
+    def has(self, name: str, branch: Branch | str | None = None) -> bool:
         branch_name = get_branch_name(branch=branch)
         if branch_name not in self._db._schemas:
             return registry.schema.has(name=name, branch=branch)
         return self._db._schemas[branch_name].has(name=name)
 
-    def get_full(
-        self, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
-    ) -> dict[str, MainSchemaTypes]:
+    def get_full(self, branch: Branch | str | None = None, duplicate: bool = True) -> dict[str, MainSchemaTypes]:
         branch_name = get_branch_name(branch=branch)
         if branch_name not in self._db._schemas:
             return registry.schema.get_full(branch=branch)
         return self._db._schemas[branch_name].get_all(duplicate=duplicate)
 
     async def get_full_safe(
-        self, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
+        self, branch: Branch | str | None = None, duplicate: bool = True
     ) -> dict[str, MainSchemaTypes]:
         await lock.registry.local_schema_wait()
         return self.get_full(branch=branch, duplicate=duplicate)
@@ -206,10 +202,10 @@ class InfrahubDatabase:
 
         return {}
 
-    def add_schema(self, schema: SchemaBranch, name: Optional[str] = None) -> None:
+    def add_schema(self, schema: SchemaBranch, name: str | None = None) -> None:
         self._schemas[name or schema.name] = schema
 
-    def start_session(self, read_only: bool = False, schemas: Optional[list[SchemaBranch]] = None) -> InfrahubDatabase:
+    def start_session(self, read_only: bool = False, schemas: list[SchemaBranch] | None = None) -> InfrahubDatabase:
         """Create a new InfrahubDatabase object in Session mode."""
         session_mode = InfrahubDatabaseSessionMode.WRITE
         if read_only:
@@ -229,7 +225,7 @@ class InfrahubDatabase:
             **context,
         )
 
-    def start_transaction(self, schemas: Optional[list[SchemaBranch]] = None) -> InfrahubDatabase:
+    def start_transaction(self, schemas: list[SchemaBranch] | None = None) -> InfrahubDatabase:
         context = self.get_context()
 
         return self.__class__(
@@ -261,7 +257,7 @@ class InfrahubDatabase:
         self._is_session_local = True
         return self._session
 
-    async def transaction(self, name: Optional[str]) -> AsyncTransaction:
+    async def transaction(self, name: str | None) -> AsyncTransaction:
         if self._transaction:
             return self._transaction
 
@@ -290,9 +286,9 @@ class InfrahubDatabase:
 
     async def __aexit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
     ):
         if self._mode == InfrahubDatabaseMode.SESSION:
             return await self._session.close()
@@ -335,6 +331,14 @@ class InfrahubDatabase:
         context: dict[str, str] | None = None,
         type: QueryType | None = None,
     ) -> 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:
@@ -385,9 +389,9 @@ class InfrahubDatabase:
                 return results, response._metadata or {}
 
     async def run_query(
-        self, query: str, params: Optional[dict[str, Any]] = None, name: Optional[str] = "undefined"
+        self, query: str, params: dict[str, Any] | None = None, name: str | None = "undefined"
     ) -> AsyncResult:
-        _query: Union[str | Query] = query
+        _query: str | Query = query
         if self.is_transaction:
             execution_method = await self.transaction(name=name)
         else:

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/dependencies/builder/constraint/grouped/node_runner.py

@@ -13,9 +13,7 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
         return NodeConstraintRunner(
             db=context.db,
             branch=context.branch,
-            node_constraints=[
-                NodeGroupedUniquenessConstraintDependency.build(context=context),
-            ],
+            uniqueness_constraint=NodeGroupedUniquenessConstraintDependency.build(context=context),
             relationship_manager_constraints=[
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),

infrahub/dependencies/component/registry.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Optional, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from ..interface import DependencyBuilderContext
 from .exceptions import UntrackedDependencyError
@@ -17,7 +17,7 @@ T = TypeVar("T")
 
 
 class ComponentDependencyRegistry:
-    the_instance: Optional[ComponentDependencyRegistry] = None
+    the_instance: ComponentDependencyRegistry | None = None
 
     def __init__(self) -> None:
         self._available_components: dict[type, type[DependencyBuilder]] = {}

infrahub/events/__init__.py

@@ -1,4 +1,27 @@
+from .artifact_action import ArtifactCreatedEvent, ArtifactUpdatedEvent
+from .branch_action import BranchCreatedEvent, BranchDeletedEvent, BranchMergedEvent, BranchRebasedEvent
+from .group_action import GroupMemberAddedEvent, GroupMemberRemovedEvent
 from .models import EventMeta, InfrahubEvent
-from .node_action import NodeMutatedEvent
+from .node_action import NodeCreatedEvent, NodeDeletedEvent, NodeUpdatedEvent
+from .repository_action import CommitUpdatedEvent
+from .validator_action import ValidatorFailedEvent, ValidatorPassedEvent, ValidatorStartedEvent
 
-__all__ = ["EventMeta", "InfrahubEvent", "NodeMutatedEvent"]
+__all__ = [
+    "ArtifactCreatedEvent",
+    "ArtifactUpdatedEvent",
+    "BranchCreatedEvent",
+    "BranchDeletedEvent",
+    "BranchMergedEvent",
+    "BranchRebasedEvent",
+    "CommitUpdatedEvent",
+    "EventMeta",
+    "GroupMemberAddedEvent",
+    "GroupMemberRemovedEvent",
+    "InfrahubEvent",
+    "NodeCreatedEvent",
+    "NodeDeletedEvent",
+    "NodeUpdatedEvent",
+    "ValidatorFailedEvent",
+    "ValidatorPassedEvent",
+    "ValidatorStartedEvent",
+]