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

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": "validate_constraint"},
+    )
     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,

infrahub/core/schema/schema_branch.py

@@ -975,6 +975,28 @@ class SchemaBranch:
                 ):
                     raise ValueError(f"{node.kind}: {rel.name} isn't allowed as a relationship name.")
 
+    def _validate_common_parent(self, node: NodeSchema, rel: RelationshipSchema) -> None:
+        if not rel.common_parent:
+            return
+
+        peer_schema = self.get(name=rel.peer, duplicate=False)
+        if not node.has_parent_relationship:
+            raise ValueError(
+                f"{node.kind}: Relationship {rel.name!r} defines 'common_parent' but node does not have a parent relationship"
+            )
+
+        try:
+            parent_rel = peer_schema.get_relationship(name=rel.common_parent)
+        except ValueError as exc:
+            raise ValueError(
+                f"{node.kind}: Relationship {rel.name!r} defines 'common_parent' but '{rel.peer}.{rel.common_parent}' does not exist"
+            ) from exc
+
+        if parent_rel.kind != RelationshipKind.PARENT:
+            raise ValueError(
+                f"{node.kind}: Relationship {rel.name!r} defines 'common_parent' but '{rel.peer}.{rel.common_parent} is not of kind 'parent'"
+            )
+
     def validate_kinds(self) -> None:
         for name in list(self.nodes.keys()):
             node = self.get_node(name=name, duplicate=False)
@@ -997,6 +1019,9 @@ class SchemaBranch:
                     raise ValueError(
                         f"{node.kind}: Relationship {rel.name!r} is referring an invalid peer {rel.peer!r}"
                     ) from None
+
+                self._validate_common_parent(node=node, rel=rel)
+
                 if rel.common_relatives:
                     peer_schema = self.get(name=rel.peer, duplicate=False)
                     for common_relatives_rel_name in rel.common_relatives:
@@ -1019,11 +1044,7 @@ class SchemaBranch:
         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
-                ):
+                if attribute.kind == "NumberPool" and isinstance(attribute.parameters, NumberPoolParameters):
                     self._validate_number_pool_parameters(
                         node_schema=node_schema, attribute=attribute, number_pool_parameters=attribute.parameters
                     )
@@ -1039,7 +1060,7 @@ class SchemaBranch:
                 f"{node_schema.kind}.{attribute.name} is a NumberPool it has to be a read_only attribute"
             )
 
-        if attribute.inherited:
+        if attribute.inherited and not number_pool_parameters.number_pool_id:
             generics_with_attribute = []
             for generic_name in node_schema.inherit_from:
                 generic_schema = self.get_generic(name=generic_name, duplicate=False)
@@ -1053,9 +1074,16 @@ class SchemaBranch:
                 raise ValidationError(
                     f"{node_schema.kind}.{attribute.name} is a NumberPool inherited from more than one generic"
                 )
+        elif not attribute.inherited:
+            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:
+                    raise ValidationError(
+                        f"Overriding '{node_schema.kind}.{attribute.name}' NumberPool attribute from generic '{generic_name}' is not supported"
+                    )
 
-        else:
-            number_pool_parameters.number_pool_id = str(uuid4())
+            if not number_pool_parameters.number_pool_id:
+                number_pool_parameters.number_pool_id = str(uuid4())
 
     def validate_computed_attributes(self) -> None:
         self.computed_attributes = ComputedAttributes()

infrahub/core/validators/__init__.py

@@ -17,7 +17,7 @@ from .node.inherit_from import NodeInheritFromChecker
 from .node.relationship import NodeRelationshipAddChecker
 from .relationship.count import RelationshipCountChecker
 from .relationship.optional import RelationshipOptionalChecker
-from .relationship.peer import RelationshipPeerChecker
+from .relationship.peer import RelationshipPeerChecker, RelationshipPeerParentChecker
 from .uniqueness.checker import UniquenessChecker
 
 CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
@@ -42,6 +42,7 @@ CONSTRAINT_VALIDATOR_MAP: dict[str, type[ConstraintCheckerInterface] | None] = {
     "relationship.optional.update": RelationshipOptionalChecker,
     "relationship.min_count.update": RelationshipCountChecker,
     "relationship.max_count.update": RelationshipCountChecker,
+    "relationship.common_parent.update": RelationshipPeerParentChecker,
     "node.inherit_from.update": NodeInheritFromChecker,
     "node.uniqueness_constraints.update": UniquenessChecker,
     "node.parent.update": NodeHierarchyChecker,

infrahub/core/validators/relationship/peer.py

@@ -2,17 +2,17 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from infrahub.core.constants import PathType
+from infrahub import config
+from infrahub.core.constants import PathType, RelationshipKind
 from infrahub.core.path import DataPath, GroupedDataPaths
 from infrahub.core.schema import GenericSchema
 
 from ..interface import ConstraintCheckerInterface
-from ..shared import (
-    RelationshipSchemaValidatorQuery,
-)
+from ..shared import RelationshipSchemaValidatorQuery
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.schema.relationship_schema import RelationshipSchema
     from infrahub.database import InfrahubDatabase
 
     from ..model import SchemaConstraintValidatorRequest
@@ -125,3 +125,173 @@ class RelationshipPeerChecker(ConstraintCheckerInterface):
             await query.execute(db=self.db)
             grouped_data_paths_list.append(await query.get_paths())
         return grouped_data_paths_list
+
+
+class RelationshipPeerParentValidatorQuery(RelationshipSchemaValidatorQuery):
+    name = "relationship_constraints_peer_parent_validator"
+
+    def __init__(
+        self,
+        relationship: RelationshipSchema,
+        parent_relationship: RelationshipSchema,
+        peer_parent_relationship: RelationshipSchema,
+        **kwargs: Any,
+    ):
+        super().__init__(**kwargs)
+
+        self.relationship = relationship
+        self.parent_relationship = parent_relationship
+        self.peer_parent_relationship = peer_parent_relationship
+
+    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(), is_isolated=False)
+        self.params.update(branch_params)
+        self.params["peer_relationship_id"] = self.relationship.identifier
+        self.params["parent_relationship_id"] = self.parent_relationship.identifier
+        self.params["peer_parent_relationship_id"] = self.peer_parent_relationship.identifier
+
+        parent_arrows = self.parent_relationship.get_query_arrows()
+        parent_match = (
+            "MATCH (active_node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(rel:Relationship { name: $parent_relationship_id })%(rstart)s[r2:IS_RELATED]%(rend)s(parent:Node)"
+        ) % {
+            "lstart": parent_arrows.left.start,
+            "lend": parent_arrows.left.end,
+            "rstart": parent_arrows.right.start,
+            "rend": parent_arrows.right.end,
+        }
+
+        peer_parent_arrows = self.relationship.get_query_arrows()
+        peer_match = (
+            "MATCH (active_node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(r:Relationship {name: $peer_relationship_id })%(rstart)s[r2:IS_RELATED]%(rend)s(peer:Node)"
+        ) % {
+            "lstart": peer_parent_arrows.left.start,
+            "lend": peer_parent_arrows.left.end,
+            "rstart": peer_parent_arrows.right.start,
+            "rend": peer_parent_arrows.right.end,
+        }
+
+        peer_parent_arrows = self.peer_parent_relationship.get_query_arrows()
+        peer_parent_match = (
+            "MATCH (peer:Node)%(lstart)s[r1:IS_RELATED]%(lend)s"
+            "(r:Relationship {name: $peer_parent_relationship_id})%(rstart)s[r2:IS_RELATED]%(rend)s(peer_parent:Node)"
+        ) % {
+            "lstart": peer_parent_arrows.left.start,
+            "lend": peer_parent_arrows.left.end,
+            "rstart": peer_parent_arrows.right.start,
+            "rend": peer_parent_arrows.right.end,
+        }
+
+        query = """
+        MATCH (n:%(node_kind)s)
+        CALL (n) {
+            MATCH path = (root:Root)<-[r:IS_PART_OF]-(n)
+            WHERE %(branch_filter)s
+            RETURN n as active_node, r.status = "active" AS is_active
+            ORDER BY r.branch_level DESC, r.from DESC
+            LIMIT 1
+        }
+        WITH active_node, is_active
+        WHERE is_active = TRUE
+        %(parent_match)s
+        WHERE all(r in [r1, r2] WHERE %(branch_filter)s AND r.status = "active")
+        CALL (active_node) {
+            %(peer_match)s
+            WITH DISTINCT active_node, peer
+            %(peer_match)s
+            WHERE all(r in [r1, r2] WHERE %(branch_filter)s)
+            WITH peer, r1.status = "active" AND r2.status = "active" AS is_active
+            ORDER BY peer.uuid, r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC, is_active DESC
+            WITH peer, head(collect(is_active)) AS is_active
+            WHERE is_active = TRUE
+            RETURN peer
+        }
+        CALL (peer) {
+            %(peer_parent_match)s
+            WHERE all(r IN [r1, r2] WHERE %(branch_filter)s)
+            WITH peer_parent, r1, r2, r1.status = "active" AND r2.status = "active" AS is_active
+            WITH peer_parent, r1.branch AS branch_name, is_active
+            ORDER BY r1.branch_level DESC, r2.branch_level DESC, r1.from DESC, r2.from DESC, is_active DESC
+            LIMIT 1
+            WITH peer_parent, branch_name
+            WHERE is_active = TRUE
+            RETURN peer_parent, branch_name
+        }
+        WITH DISTINCT active_node, parent, peer, peer_parent, branch_name
+        WHERE parent.uuid <> peer_parent.uuid
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kind": self.node_schema.kind,
+            "parent_match": parent_match,
+            "peer_match": peer_match,
+            "peer_parent_match": peer_parent_match,
+        }
+
+        self.add_to_query(query)
+        self.return_labels = ["active_node.uuid", "parent.uuid", "peer.uuid", "peer_parent.uuid", "branch_name"]
+
+    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("branch_name")),
+                    path_type=PathType.RELATIONSHIP_ONE,
+                    node_id=str(result.get("peer.uuid")),
+                    field_name=self.peer_parent_relationship.name,
+                    peer_id=str(result.get("peer_parent.uuid")),
+                    kind=self.relationship.peer,
+                )
+            )
+
+        return grouped_data_paths
+
+
+class RelationshipPeerParentChecker(ConstraintCheckerInterface):
+    query_classes = [RelationshipPeerParentValidatorQuery]
+
+    def __init__(self, db: InfrahubDatabase, branch: Branch | None = None) -> None:
+        self.db = db
+        self.branch = branch
+
+    @property
+    def name(self) -> str:
+        return "relationship.common_parent.update"
+
+    def supports(self, request: SchemaConstraintValidatorRequest) -> bool:
+        return request.constraint_name == self.name and config.SETTINGS.main.schema_strict_mode
+
+    async def check(self, request: SchemaConstraintValidatorRequest) -> list[GroupedDataPaths]:
+        grouped_data_paths_list: list[GroupedDataPaths] = []
+
+        if not request.schema_path.field_name:
+            return grouped_data_paths_list
+
+        relationship = request.node_schema.get_relationship(name=request.schema_path.field_name)
+        if not relationship.common_parent:
+            # Should not happen if schema validation was done properly
+            return grouped_data_paths_list
+
+        parent_relationship = next(
+            iter(request.node_schema.get_relationships_of_kind(relationship_kinds=[RelationshipKind.PARENT]))
+        )
+        peer_parent_relationship = request.schema_branch.get(name=relationship.peer, duplicate=False).get_relationship(
+            name=relationship.common_parent
+        )
+
+        for query_class in self.query_classes:
+            query = await query_class.init(
+                db=self.db,
+                branch=self.branch,
+                node_schema=request.node_schema,
+                schema_path=request.schema_path,
+                relationship=relationship,
+                parent_relationship=parent_relationship,
+                peer_parent_relationship=peer_parent_relationship,
+            )
+            await query.execute(db=self.db)
+            grouped_data_paths_list.append(await query.get_paths())
+
+        return grouped_data_paths_list

infrahub/database/__init__.py

@@ -498,7 +498,6 @@ async def get_db(retry: int = 0) -> AsyncDriver:
         trusted_certificates=trusted_certificates,
         notifications_disabled_categories=[
             NotificationDisabledCategory.UNRECOGNIZED,
-            NotificationDisabledCategory.DEPRECATION,  # TODO: Remove me with 1.3
         ],
         notifications_min_severity=NotificationMinimumSeverity.WARNING,
     )

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_parent import RelationshipPeerParentConstraintDependency
 from ..relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from ..relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 
@@ -19,6 +20,7 @@ class NodeConstraintRunnerDependency(DependencyBuilder[NodeConstraintRunner]):
                 RelationshipPeerKindConstraintDependency.build(context=context),
                 RelationshipCountConstraintDependency.build(context=context),
                 RelationshipProfilesKindConstraintDependency.build(context=context),
+                RelationshipPeerParentConstraintDependency.build(context=context),
                 RelationshipPeerRelativesConstraintDependency.build(context=context),
             ],
         )

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

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

infrahub/dependencies/builder/constraint/schema/aggregated.py

@@ -14,6 +14,7 @@ from .node_attribute import SchemaNodeAttributeAddConstraintDependency
 from .node_relationship import SchemaNodeRelationshipAddConstraintDependency
 from .relationship_count import SchemaRelationshipCountConstraintDependency
 from .relationship_optional import SchemaRelationshipOptionalConstraintDependency
+from .relationship_peer import SchemaRelationshipPeerParentConstraintDependency
 from .uniqueness import SchemaUniquenessConstraintDependency
 
 
@@ -36,6 +37,7 @@ class AggregatedSchemaConstraintsDependency(DependencyBuilder[AggregatedConstrai
                 SchemaAttributeKindConstraintDependency.build(context=context),
                 SchemaNodeAttributeAddConstraintDependency.build(context=context),
                 SchemaNodeRelationshipAddConstraintDependency.build(context=context),
+                SchemaRelationshipPeerParentConstraintDependency.build(context=context),
             ],
             db=context.db,
             branch=context.branch,

infrahub/dependencies/builder/constraint/schema/relationship_peer.py

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

infrahub/dependencies/registry.py

@@ -3,6 +3,7 @@ from .builder.constraint.node.grouped_uniqueness import NodeGroupedUniquenessCon
 from .builder.constraint.node.uniqueness import NodeAttributeUniquenessConstraintDependency
 from .builder.constraint.relationship_manager.count import RelationshipCountConstraintDependency
 from .builder.constraint.relationship_manager.peer_kind import RelationshipPeerKindConstraintDependency
+from .builder.constraint.relationship_manager.peer_parent import RelationshipPeerParentConstraintDependency
 from .builder.constraint.relationship_manager.peer_relatives import RelationshipPeerRelativesConstraintDependency
 from .builder.constraint.relationship_manager.profiles_kind import RelationshipProfilesKindConstraintDependency
 from .builder.constraint.schema.aggregated import AggregatedSchemaConstraintsDependency
@@ -38,6 +39,7 @@ def build_component_registry() -> ComponentDependencyRegistry:
     component_registry.track_dependency(RelationshipCountConstraintDependency)
     component_registry.track_dependency(RelationshipProfilesKindConstraintDependency)
     component_registry.track_dependency(RelationshipPeerKindConstraintDependency)
+    component_registry.track_dependency(RelationshipPeerParentConstraintDependency)
     component_registry.track_dependency(RelationshipPeerRelativesConstraintDependency)
     component_registry.track_dependency(NodeConstraintRunnerDependency)
     component_registry.track_dependency(NodeDeleteValidatorDependency)

infrahub/git/tasks.py

@@ -696,6 +696,7 @@ async def trigger_internal_checks(
         if (
             existing_validator.typename == InfrahubKind.REPOSITORYVALIDATOR
             and existing_validator.repository.id == model.repository
+            and existing_validator.label.value == validator_name
         ):
             previous_validator = existing_validator
 

infrahub/graphql/mutations/convert_object_type.py

@@ -6,6 +6,7 @@ from graphql import GraphQLResolveInfo
 
 from infrahub.core import registry
 from infrahub.core.convert_object_type.conversion import InputForDestField, convert_object_type
+from infrahub.core.convert_object_type.schema_mapping import get_schema_mapping
 from infrahub.core.manager import NodeManager
 
 if TYPE_CHECKING:
@@ -16,7 +17,6 @@ class ConvertObjectTypeInput(InputObjectType):
     node_id = String(required=True)
     target_kind = String(required=True)
     fields_mapping = GenericScalar(required=True)  # keys are destination attributes/relationships names.
-    branch = String(required=True)
 
 
 class ConvertObjectType(Mutation):
@@ -37,17 +37,26 @@ class ConvertObjectType(Mutation):
 
         graphql_context: GraphqlContext = info.context
 
+        node_to_convert = await NodeManager.get_one(
+            id=str(data.node_id), db=graphql_context.db, branch=graphql_context.branch
+        )
+
+        source_schema = registry.get_node_schema(name=node_to_convert.get_kind(), branch=graphql_context.branch)
+        target_schema = registry.get_node_schema(name=str(data.target_kind), branch=graphql_context.branch)
+
         fields_mapping: dict[str, InputForDestField] = {}
         if not isinstance(data.fields_mapping, dict):
             raise ValueError(f"Expected `fields_mapping` to be a `dict`, got {type(fields_mapping)}")
 
-        for field, input_for_dest_field_str in data.fields_mapping.items():
-            fields_mapping[field] = InputForDestField(**input_for_dest_field_str)
+        for field_name, input_for_dest_field_str in data.fields_mapping.items():
+            fields_mapping[field_name] = InputForDestField(**input_for_dest_field_str)
+
+        # Complete fields mapping with auto-mapping.
+        mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
+        for field_name, mapping_value in mapping.items():
+            if mapping_value.source_field_name is not None and field_name not in fields_mapping:
+                fields_mapping[field_name] = InputForDestField(source_field=mapping_value.source_field_name)
 
-        node_to_convert = await NodeManager.get_one(
-            id=str(data.node_id), db=graphql_context.db, branch=str(data.branch)
-        )
-        target_schema = registry.get_node_schema(name=str(data.target_kind), branch=data.branch)
         new_node = await convert_object_type(
             node=node_to_convert,
             target_schema=target_schema,

infrahub/graphql/mutations/relationship.py

@@ -85,6 +85,7 @@ class RelationshipAdd(Mutation):
         nodes = await _validate_peers(info=info, data=data)
         await _validate_permissions(info=info, source_node=source, peers=nodes)
         await _validate_peer_types(info=info, data=data, source_node=source, peers=nodes)
+        await _validate_peer_parents(info=info, data=data, source_node=source, peers=nodes)
 
         # This has to be done after validating the permissions
         await apply_external_context(graphql_context=graphql_context, context_input=context)
@@ -406,6 +407,37 @@ async def _validate_peer_types(
                     )
 
 
+async def _validate_peer_parents(
+    info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node, peers: dict[str, Node]
+) -> None:
+    relationship_name = str(data.name)
+    rel_schema = source_node.get_schema().get_relationship(name=relationship_name)
+    if not rel_schema.common_parent:
+        return
+
+    graphql_context: GraphqlContext = info.context
+
+    source_node_parent = await source_node.get_parent_relationship_peer(
+        db=graphql_context.db, name=rel_schema.common_parent
+    )
+    if not source_node_parent:
+        # If the schema is properly validated we are not expecting this to happen
+        raise ValidationError(f"Node {source_node.id} ({source_node.get_kind()!r}) does not have a parent peer")
+
+    parents: set[str] = {source_node_parent.id}
+    for peer in peers.values():
+        peer_parent = await peer.get_parent_relationship_peer(db=graphql_context.db, name=rel_schema.common_parent)
+        if not peer_parent:
+            # If the schema is properly validated we are not expecting this to happen
+            raise ValidationError(f"Peer {peer.id} ({peer.get_kind()!r}) does not have a parent peer")
+        parents.add(peer_parent.id)
+
+    if len(parents) > 1:
+        raise ValidationError(
+            f"Cannot relate {source_node.id!r} to '{relationship_name}' peers that do not have the same parent"
+        )
+
+
 async def _collect_current_peers(
     info: GraphQLResolveInfo, data: RelationshipNodesInput, source_node: Node
 ) -> dict[str, RelationshipPeerData]:

infrahub/graphql/queries/convert_object_type_mapping.py

@@ -12,13 +12,12 @@ class FieldsMapping(ObjectType):
 
 async def fields_mapping_type_conversion_resolver(
     root: dict,  # noqa: ARG001
-    info: GraphQLResolveInfo,  # noqa: ARG001
+    info: GraphQLResolveInfo,
     source_kind: str,
     target_kind: str,
-    branch: str,
 ) -> dict:
-    source_schema = registry.get_node_schema(name=source_kind, branch=branch)
-    target_schema = registry.get_node_schema(name=target_kind, branch=branch)
+    source_schema = registry.get_node_schema(name=source_kind, branch=info.context.branch)
+    target_schema = registry.get_node_schema(name=target_kind, branch=info.context.branch)
 
     mapping = get_schema_mapping(source_schema=source_schema, target_schema=target_schema)
     mapping_dict = {field_name: model.model_dump(mode="json") for field_name, model in mapping.items()}
@@ -29,7 +28,6 @@ FieldsMappingTypeConversion = Field(
     FieldsMapping,
     source_kind=String(),
     target_kind=String(),
-    branch=String(),
     description="Retrieve fields mapping for converting object type",
     resolver=fields_mapping_type_conversion_resolver,
     required=True,

infrahub/message_bus/operations/refresh/registry.py

@@ -1,5 +1,3 @@
-from infrahub import lock
-from infrahub.core.registry import registry
 from infrahub.message_bus import messages
 from infrahub.services import InfrahubServices
 from infrahub.tasks.registry import refresh_branches
@@ -24,8 +22,7 @@ async def rebased_branch(message: messages.RefreshRegistryRebasedBranch, service
         )
         return
 
-    async with lock.registry.local_schema_lock():
-        service.log.info("Refreshing rebased branch")
+    async with service.database.start_session(read_only=True) as db:
+        await refresh_branches(db=db)
 
-        async with service.database.start_session(read_only=True) as db:
-            registry.branch[message.branch] = await registry.branch_object.get_by_name(name=message.branch, db=db)
+    await service.component.refresh_schema_hash()

infrahub/pools/models.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class NumberPoolLockDefinition:
+    pool_id: str
+
+    @property
+    def lock_name(self) -> str:
+        return f"number-pool-creation-{self.pool_id}"
+
+    @property
+    def namespace_name(self) -> str:
+        return "number-pool"

infrahub/pools/tasks.py

@@ -3,12 +3,16 @@ from __future__ import annotations
 from prefect import flow
 from prefect.logging import get_run_logger
 
+from infrahub import lock
 from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
-from infrahub.core.constants import NumberPoolType
+from infrahub.core.constants import InfrahubKind, NumberPoolType
 from infrahub.core.manager import NodeManager
+from infrahub.core.node import Node
 from infrahub.core.protocols import CoreNumberPool
 from infrahub.core.registry import registry
 from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+from infrahub.exceptions import NodeNotFoundError
+from infrahub.pools.models import NumberPoolLockDefinition
 from infrahub.pools.registration import get_branches_with_schema_number_pool
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 
@@ -54,3 +58,69 @@ async def validate_schema_number_pools(
         elif not defined_on_branches:
             log.info(f"Deleting number pool (id={schema_number_pool.id}) as it is no longer defined in the schema")
             await schema_number_pool.delete(db=service.database)
+
+    existing_pool_ids = [pool.id for pool in schema_number_pools]
+    for registry_branch in registry.schema.get_branches():
+        schema_branch = service.database.schema.get_schema_branch(name=registry_branch)
+
+        for generic_name in schema_branch.generic_names:
+            generic_node = schema_branch.get_generic(name=generic_name, duplicate=False)
+            for attribute_name in generic_node.attribute_names:
+                attribute = generic_node.get_attribute(name=attribute_name)
+                if isinstance(attribute.parameters, NumberPoolParameters) and attribute.parameters.number_pool_id:
+                    if attribute.parameters.number_pool_id not in existing_pool_ids:
+                        await _create_number_pool(
+                            service=service,
+                            number_pool_id=attribute.parameters.number_pool_id,
+                            pool_node=generic_node.kind,
+                            pool_attribute=attribute_name,
+                            start_range=attribute.parameters.start_range,
+                            end_range=attribute.parameters.end_range,
+                        )
+                        existing_pool_ids.append(attribute.parameters.number_pool_id)
+
+        for node_name in schema_branch.node_names:
+            node = schema_branch.get_node(name=node_name, duplicate=False)
+            for attribute_name in node.attribute_names:
+                attribute = node.get_attribute(name=attribute_name)
+                if isinstance(attribute.parameters, NumberPoolParameters) and attribute.parameters.number_pool_id:
+                    if attribute.parameters.number_pool_id not in existing_pool_ids:
+                        await _create_number_pool(
+                            service=service,
+                            number_pool_id=attribute.parameters.number_pool_id,
+                            pool_node=node.kind,
+                            pool_attribute=attribute_name,
+                            start_range=attribute.parameters.start_range,
+                            end_range=attribute.parameters.end_range,
+                        )
+                        existing_pool_ids.append(attribute.parameters.number_pool_id)
+
+
+async def _create_number_pool(
+    service: InfrahubServices,
+    number_pool_id: str,
+    pool_node: str,
+    pool_attribute: str,
+    start_range: int,
+    end_range: int,
+) -> None:
+    lock_definition = NumberPoolLockDefinition(pool_id=number_pool_id)
+    async with lock.registry.get(name=lock_definition.lock_name, namespace=lock_definition.namespace_name, local=False):
+        async with service.database.start_session() as dbs:
+            try:
+                await registry.manager.get_one_by_id_or_default_filter(
+                    db=dbs, id=str(number_pool_id), kind=CoreNumberPool
+                )
+            except NodeNotFoundError:
+                number_pool = await Node.init(db=dbs, schema=InfrahubKind.NUMBERPOOL, branch=registry.default_branch)
+                await number_pool.new(
+                    db=dbs,
+                    id=number_pool_id,
+                    name=f"{pool_node}.{pool_attribute} [{number_pool_id}]",
+                    node=pool_node,
+                    node_attribute=pool_attribute,
+                    start_range=start_range,
+                    end_range=end_range,
+                    pool_type=NumberPoolType.SCHEMA.value,
+                )
+                await number_pool.save(db=dbs)