infrahub-server 1.3.3__py3-none-any.whl → 1.3.4__py3-none-any.whl

infrahub/core/query/resource_manager.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Generator
+
+from pydantic import BaseModel, ConfigDict
 
 from infrahub.core import registry
 from infrahub.core.constants import InfrahubKind, RelationshipStatus
@@ -11,6 +13,13 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
+class NumberPoolIdentifierData(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    value: int
+    identifier: str
+
+
 class IPAddressPoolGetIdentifiers(Query):
     name = "ipaddresspool_get_identifiers"
     type = QueryType.READ
@@ -158,7 +167,7 @@ class NumberPoolGetReserved(Query):
     def __init__(
         self,
         pool_id: str,
-        identifier: str,
+        identifier: str | None = None,
         **kwargs: dict[str, Any],
     ) -> None:
         self.pool_id = pool_id
@@ -176,26 +185,104 @@ class NumberPoolGetReserved(Query):
 
         self.params.update(branch_params)
 
+        # If identifier is not provided, we return all reservations for the pool
+        identifier_filter = ""
+        if self.identifier:
+            identifier_filter = "r.identifier = $identifier AND "
+            self.params["identifier"] = self.identifier
+
         query = """
         MATCH (pool:%(number_pool)s { uuid: $pool_id })-[r:IS_RESERVED]->(reservation:AttributeValue)
         WHERE
-            r.identifier = $identifier
-            AND
+            %(identifier_filter)s
             %(branch_filter)s
-        """ % {"branch_filter": branch_filter, "number_pool": InfrahubKind.NUMBERPOOL}
+        """ % {
+            "branch_filter": branch_filter,
+            "number_pool": InfrahubKind.NUMBERPOOL,
+            "identifier_filter": identifier_filter,
+        }
         self.add_to_query(query)
-        self.return_labels = ["reservation.value"]
+        self.return_labels = ["reservation.value AS value", "r.identifier AS identifier"]
 
     def get_reservation(self) -> int | None:
         result = self.get_result()
         if result:
-            return result.get_as_optional_type("reservation.value", return_type=int)
+            return result.get_as_optional_type("value", return_type=int)
         return None
 
+    def get_reservations(self) -> Generator[NumberPoolIdentifierData]:
+        for result in self.results:
+            yield NumberPoolIdentifierData.model_construct(
+                value=result.get_as_type("value", return_type=int),
+                identifier=result.get_as_type("identifier", return_type=str),
+            )
+
+
+class PoolChangeReserved(Query):
+    """Change the identifier on all pools.
+    This is useful when a node is being converted to a different type and its ID has changed
+    """
+
+    name = "pool_change_reserved"
+    type = QueryType.WRITE
+
+    def __init__(
+        self,
+        existing_identifier: str,
+        new_identifier: str,
+        **kwargs: dict[str, Any],
+    ) -> None:
+        self.existing_identifier = existing_identifier
+        self.new_identifier = new_identifier
+
+        super().__init__(**kwargs)  # type: ignore[arg-type]
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        self.params["new_identifier"] = self.new_identifier
+        self.params["existing_identifier"] = self.existing_identifier
+        self.params["at"] = self.at.to_string()
+
+        branch_filter, branch_params = self.branch.get_query_filter_path(
+            at=self.at.to_string(), branch_agnostic=self.branch_agnostic
+        )
+
+        self.params.update(branch_params)
+
+        global_branch = registry.get_global_branch()
+        self.params["rel_prop"] = {
+            "branch": global_branch.name,
+            "branch_level": global_branch.hierarchy_level,
+            "status": RelationshipStatus.ACTIVE.value,
+            "from": self.at.to_string(),
+            "identifier": self.new_identifier,
+        }
+
+        query = """
+        MATCH (pool:Node)-[r:IS_RESERVED]->(resource)
+        WHERE
+            r.identifier = $existing_identifier
+            AND
+            %(branch_filter)s
+        SET r.to = $at
+        CREATE (pool)-[new_rel:IS_RESERVED $rel_prop]->(resource)
+        """ % {"branch_filter": branch_filter}
+        self.add_to_query(query)
+        self.return_labels = ["pool.uuid AS pool_id", "r", "new_rel"]
+
+
+"""
+Important!: The relationship IS_RESERVED for Number is not being cleaned up when the node or the branch is deleted
+I think this is something we should address in the future.
+It works for now because the query has been updated to match the identifier in IS_RESERVED with the UUID of the related node
+But in the future, if we need to use an identifier that is not the UUID, we will need to clean up the relationships
+This will be especially important as we want to support upsert with NumberPool
+"""
+
 
 class NumberPoolGetUsed(Query):
     name = "number_pool_get_used"
     type = QueryType.READ
+    return_model = NumberPoolIdentifierData
 
     def __init__(
         self,
@@ -219,26 +306,36 @@ class NumberPoolGetUsed(Query):
         self.params["attribute_name"] = self.pool.node_attribute.value
 
         query = """
-        MATCH (pool:%(number_pool)s { uuid: $pool_id })
-        CALL (pool) {
-            MATCH (pool)-[res:IS_RESERVED]->(av:AttributeValue)<-[hv:HAS_VALUE]-(attr:Attribute)
+        MATCH (pool:%(number_pool)s { uuid: $pool_id })-[res:IS_RESERVED]->(av:AttributeValue)
+        WHERE toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
+        CALL (pool, res, av) {
+            MATCH (pool)-[res]->(av)<-[hv:HAS_VALUE]-(attr:Attribute)<-[ha:HAS_ATTRIBUTE]-(n:%(node)s)
             WHERE
-                attr.name = $attribute_name
-                AND
-                toInteger(av.value) >= $start_range and toInteger(av.value) <= $end_range
-                AND
-                all(r in [res, hv] WHERE (%(branch_filter)s))
-            RETURN av, (res.status = "active" AND hv.status = "active") AS is_active
+                n.uuid = res.identifier AND
+                attr.name = $attribute_name AND
+                all(r in [res, hv, ha] WHERE (%(branch_filter)s))
+            ORDER BY res.branch_level DESC, hv.branch_level DESC, ha.branch_level DESC, res.from DESC, hv.from DESC, ha.from DESC
+            RETURN (res.status = "active" AND hv.status = "active" AND ha.status = "active") AS is_active
+            LIMIT 1
         }
-        WITH av, is_active
-        WHERE is_active = TRUE
+        WITH av, res, is_active
+        WHERE is_active = True
         """ % {
             "branch_filter": branch_filter,
             "number_pool": InfrahubKind.NUMBERPOOL,
+            "node": self.pool.node.value,
         }
+
         self.add_to_query(query)
-        self.return_labels = ["av.value"]
-        self.order_by = ["av.value"]
+        self.return_labels = ["DISTINCT(av.value) as value", "res.identifier as identifier"]
+        self.order_by = ["value"]
+
+    def iter_results(self) -> Generator[NumberPoolIdentifierData]:
+        for result in self.results:
+            yield self.return_model.model_construct(
+                value=result.get_as_type("value", return_type=int),
+                identifier=result.get_as_type("identifier", return_type=str),
+            )
 
 
 class NumberPoolSetReserved(Query):

infrahub/core/schema/__init__.py

@@ -46,6 +46,7 @@ class SchemaExtension(HashableModel):
 
 class SchemaRoot(BaseModel):
     model_config = ConfigDict(extra="forbid")
+
     version: str | None = Field(default=None)
     generics: list[GenericSchema] = Field(default_factory=list)
     nodes: list[NodeSchema] = Field(default_factory=list)
@@ -93,6 +94,10 @@ class SchemaRoot(BaseModel):
         """Return a new `SchemaRoot` after merging `self` with `schema`."""
         return SchemaRoot.model_validate(deep_merge_dict(dicta=self.model_dump(), dictb=schema.model_dump()))
 
+    def duplicate(self) -> SchemaRoot:
+        """Return a duplicate of the current schema."""
+        return SchemaRoot.model_validate(self.model_dump())
+
 
 internal_schema = internal.to_dict()
 

infrahub/core/schema/attribute_parameters.py

@@ -165,3 +165,9 @@ class NumberPoolParameters(AttributeParameters):
         if self.start_range > self.end_range:
             raise ValueError("`start_range` can't be less than `end_range`")
         return self
+
+    def get_pool_size(self) -> int:
+        """
+        Returns the size of the pool based on the defined ranges.
+        """
+        return self.end_range - self.start_range + 1

infrahub/core/schema/attribute_schema.py

@@ -10,6 +10,7 @@ from infrahub import config
 from infrahub.core.constants.schema import UpdateSupport
 from infrahub.core.enums import generate_python_enum
 from infrahub.core.query.attribute import default_attribute_query_filter
+from infrahub.exceptions import InitializationError
 from infrahub.types import ATTRIBUTE_KIND_LABELS, ATTRIBUTE_TYPES
 
 from .attribute_parameters import (
@@ -67,6 +68,11 @@ class AttributeSchema(GeneratedAttributeSchema):
     def is_deprecated(self) -> bool:
         return bool(self.deprecation)
 
+    def get_id(self) -> str:
+        if self.id is None:
+            raise InitializationError("The attribute schema has not been saved yet and doesn't have an id")
+        return self.id
+
     def to_dict(self) -> dict:
         data = self.model_dump(exclude_unset=True, exclude_none=True)
         for field_name, value in data.items():

infrahub/core/schema/manager.py

@@ -535,7 +535,7 @@ class SchemaManager(NodeManager):
         """Delete the node with its attributes and relationships."""
         branch = await registry.get_branch(branch=branch, db=db)
 
-        obj = await self.get_one(id=node.get_id(), branch=branch, db=db)
+        obj = await self.get_one(id=node.get_id(), branch=branch, db=db, prefetch_relationships=True)
         if not obj:
             raise SchemaNotFoundError(
                 branch_name=branch.name,
@@ -544,16 +544,10 @@ class SchemaManager(NodeManager):
             )
 
         # First delete the attributes and the relationships
-        items = await self.get_many(
-            ids=[item.id for item in node.local_attributes + node.local_relationships if item.id],
-            db=db,
-            branch=branch,
-            include_owner=True,
-            include_source=True,
-        )
-
-        for item in items.values():
-            await item.delete(db=db)
+        for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
+            await attr_schema_node.delete(db=db)
+        for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
+            await rel_schema_node.delete(db=db)
 
         await obj.delete(db=db)
 

infrahub/core/schema/relationship_schema.py

@@ -9,6 +9,7 @@ from infrahub import config
 from infrahub.core.constants import RelationshipDirection
 from infrahub.core.query import QueryNode, QueryRel, QueryRelDirection
 from infrahub.core.relationship import Relationship
+from infrahub.exceptions import InitializationError
 
 from .generated.relationship_schema import GeneratedRelationshipSchema
 
@@ -57,6 +58,11 @@ class RelationshipSchema(GeneratedRelationshipSchema):
             raise ValueError("RelationshipSchema is not initialized")
         return self.identifier
 
+    def get_id(self) -> str:
+        if not self.id:
+            raise InitializationError("The relationship schema has not been saved yet and doesn't have an id")
+        return self.id
+
     def get_query_arrows(self) -> QueryArrows:
         """Return (in 4 parts) the 2 arrows for the relationship R1 and R2 based on the direction of the relationship."""
 

infrahub/core/schema/schema_branch.py

@@ -1588,7 +1588,8 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
-    def generate_weight(self) -> None:
+    def _generate_weight_generics(self) -> None:
+        """Generate order_weight for all generic schemas."""
         for name in self.generic_names:
             node = self.get(name=name, duplicate=False)
 
@@ -1606,6 +1607,8 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def _generate_weight_nodes_profiles(self) -> None:
+        """Generate order_weight for all nodes and profiles."""
         for name in self.node_names + self.profile_names:
             node = self.get(name=name, duplicate=False)
 
@@ -1630,6 +1633,33 @@ class SchemaBranch:
 
             self.set(name=name, schema=node)
 
+    def _generate_weight_templates(self) -> None:
+        """Generate order_weight for all templates.
+
+        The order of the fields for the template must respect the order of the node.
+        """
+        for name in self.template_names:
+            template = self.get(name=name, duplicate=True)
+            node = self.get(name=template.name, duplicate=False)
+
+            node_weights = {
+                item.name: item.order_weight
+                for item in node.attributes + node.relationships
+                if item.order_weight is not None
+            }
+
+            for item in template.attributes + template.relationships:
+                if item.order_weight:
+                    continue
+                item.order_weight = node_weights[item.name] + 10000 if item.name in node_weights else None
+
+            self.set(name=name, schema=template)
+
+    def generate_weight(self) -> None:
+        self._generate_weight_generics()
+        self._generate_weight_nodes_profiles()
+        self._generate_weight_templates()
+
     def cleanup_inherited_elements(self) -> None:
         for name in self.node_names:
             node = self.get_node(name=name, duplicate=False)
@@ -2038,25 +2068,34 @@ class SchemaBranch:
                 if relationship.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC]
                 else relationship.peer
             )
+
+            is_optional = (
+                relationship.optional if is_autogenerated_subtemplate else relationship.kind != RelationshipKind.PARENT
+            )
+            identifier = (
+                f"template_{relationship.identifier}"
+                if relationship.identifier
+                else self._generate_identifier_string(template_schema.kind, rel_template_peer)
+            )
+            label = (
+                f"{relationship.name} template".title()
+                if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
+                else relationship.name.title()
+            )
+
             template_schema.relationships.append(
                 RelationshipSchema(
                     name=relationship.name,
                     peer=rel_template_peer,
                     kind=relationship.kind,
-                    optional=relationship.optional
-                    if is_autogenerated_subtemplate
-                    else relationship.kind != RelationshipKind.PARENT,
+                    optional=is_optional,
                     cardinality=relationship.cardinality,
                     direction=relationship.direction,
                     branch=relationship.branch,
-                    identifier=f"template_{relationship.identifier}"
-                    if relationship.identifier
-                    else self._generate_identifier_string(template_schema.kind, rel_template_peer),
+                    identifier=identifier,
                     min_count=relationship.min_count,
                     max_count=relationship.max_count,
-                    label=f"{relationship.name} template".title()
-                    if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
-                    else relationship.name.title(),
+                    label=label,
                     inherited=relationship.inherited,
                 )
             )
@@ -2144,7 +2183,7 @@ class SchemaBranch:
             attr_schema_class = get_attribute_schema_class_for_kind(kind=node_attr.kind)
             attr = attr_schema_class(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only"]),
+                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "order_weight"]),
             )
             template.attributes.append(attr)
 

infrahub/core/validators/node/attribute.py

@@ -2,6 +2,9 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub.core import registry
+from infrahub.core.schema.attribute_parameters import NumberPoolParameters
+
 from ..interface import ConstraintCheckerInterface
 from ..query import NodeNotPresentValidatorQuery
 
@@ -31,10 +34,22 @@ class NodeAttributeAddChecker(ConstraintCheckerInterface):
         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 attribute_schema.optional is True or attribute_schema.default_value is not None:
             return grouped_data_paths_list
 
+        # If the attribute is a NumberPool, we need to ensure that the pool is big enough for all existing nodes
+        if attribute_schema.kind == "NumberPool" and isinstance(attribute_schema.parameters, NumberPoolParameters):
+            nbr_nodes = await registry.manager.count(db=self.db, branch=self.branch, schema=request.node_schema)
+            pool_size = attribute_schema.parameters.get_pool_size()
+
+            if pool_size < nbr_nodes:
+                raise ValueError(
+                    f"The size of the NumberPool is smaller than the number of existing nodes {pool_size} < {nbr_nodes}."
+                )
+            return grouped_data_paths_list
+
         for query_class in self.query_classes:
             # TODO add exception handling
             query = await query_class.init(

infrahub/core/validators/tasks.py

@@ -11,9 +11,7 @@ from infrahub.core.branch import Branch  # noqa: TC001
 from infrahub.core.path import SchemaPath  # noqa: TC001
 from infrahub.core.schema import GenericSchema, NodeSchema
 from infrahub.core.validators.aggregated_checker import AggregatedConstraintChecker
-from infrahub.core.validators.model import (
-    SchemaConstraintValidatorRequest,
-)
+from infrahub.core.validators.model import SchemaConstraintValidatorRequest, SchemaViolation
 from infrahub.dependencies.registry import get_component_registry
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
 from infrahub.workflows.utils import add_tags
@@ -84,7 +82,17 @@ async def schema_path_validate(
         aggregated_constraint_checker = await component_registry.get_component(
             AggregatedConstraintChecker, db=db, branch=branch
         )
-        violations = await aggregated_constraint_checker.run_constraints(constraint_request)
+        try:
+            violations = await aggregated_constraint_checker.run_constraints(constraint_request)
+        except Exception as exc:
+            violation = SchemaViolation(
+                node_id="unknown",
+                node_kind=node_schema.kind,
+                display_label=f"Error validating {constraint_name} on {node_schema.kind}",
+                full_display_label=f"Error validating {constraint_name} on {node_schema.kind}",
+                message=str(exc),
+            )
+            violations = [violation]
 
         return SchemaValidatorPathResponseData(
             violations=violations, constraint_name=constraint_name, schema_path=schema_path

infrahub/graphql/queries/resource_manager.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Field, Float, Int, List, NonNull, ObjectType, String
+from graphene import BigInt, Field, Float, Int, List, NonNull, ObjectType, String
 from infrahub_sdk.utils import extract_fields_first_node
 
 from infrahub.core import registry
@@ -33,7 +33,7 @@ class IPPoolUtilizationResource(ObjectType):
     id = Field(String, required=True, description="The ID of the current resource")
     display_label = Field(String, required=True, description="The common name of the resource")
     kind = Field(String, required=True, description="The resource kind")
-    weight = Field(Int, required=True, description="The relative weight of this resource.")
+    weight = Field(BigInt, required=True, description="The relative weight of this resource.")
     utilization = Field(Float, required=True, description="The overall utilization of the resource.")
     utilization_branches = Field(
         Float, required=True, description="The utilization of the resource on all non default branches."
@@ -70,7 +70,7 @@ def _validate_pool_type(pool_id: str, pool: CoreNode | None = None) -> CoreNode:
 
 
 class PoolAllocated(ObjectType):
-    count = Field(Int, required=True, description="The number of allocations within the selected pool.")
+    count = Field(BigInt, required=True, description="The number of allocations within the selected pool.")
     edges = Field(List(of_type=NonNull(PoolAllocatedEdge), required=True), required=True)
 
     @staticmethod
@@ -174,7 +174,7 @@ class PoolAllocated(ObjectType):
 
 
 class PoolUtilization(ObjectType):
-    count = Field(Int, required=True, description="The number of resources within the selected pool.")
+    count = Field(BigInt, required=True, description="The number of resources within the selected pool.")
     utilization = Field(Float, required=True, description="The overall utilization of the pool.")
     utilization_branches = Field(Float, required=True, description="The utilization in all non default branches.")
     utilization_default_branch = Field(

infrahub/tasks/registry.py

@@ -1,17 +1,77 @@
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 from infrahub import lock
 from infrahub.core import registry
-from infrahub.database import InfrahubDatabase
 from infrahub.log import get_logger
 from infrahub.worker import WORKER_IDENTITY
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.schema.schema_branch import SchemaBranch
+    from infrahub.database import InfrahubDatabase
 
 log = get_logger()
 
 
+def update_graphql_schema(branch: Branch, schema_branch: SchemaBranch) -> None:
+    """
+    Update the GraphQL schema for the given branch.
+    """
+    from infrahub.graphql.manager import GraphQLSchemaManager
+
+    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=branch, schema_branch=schema_branch)
+    gqlm.get_graphql_schema(
+        include_query=True,
+        include_mutation=True,
+        include_subscription=True,
+        include_types=True,
+    )
+
+
+async def create_branch_registry(db: InfrahubDatabase, branch: Branch) -> None:
+    """Create a new entry in the registry for a given branch."""
+
+    log.info("New branch detected, pulling schema", branch=branch.name, worker=WORKER_IDENTITY)
+    await registry.schema.load_schema(db=db, branch=branch)
+    registry.branch[branch.name] = branch
+    schema_branch = registry.schema.get_schema_branch(name=branch.name)
+    update_graphql_schema(branch=branch, schema_branch=schema_branch)
+
+
+async def update_branch_registry(db: InfrahubDatabase, branch: Branch) -> None:
+    """Update the registry for a branch if the schema hash has changed."""
+
+    existing_branch: Branch = registry.branch[branch.name]
+
+    if not existing_branch.schema_hash:
+        log.warning("Branch schema hash is not set, cannot update branch registry")
+        return
+
+    if existing_branch.schema_hash and existing_branch.schema_hash.main == branch.active_schema_hash.main:
+        log.debug(
+            "Branch schema hash is the same, no need to update branch registry",
+            branch=branch.name,
+            hash=existing_branch.schema_hash.main,
+            worker=WORKER_IDENTITY,
+        )
+        return
+
+    log.info(
+        "New hash detected",
+        branch=branch.name,
+        hash_current=existing_branch.schema_hash.main,
+        hash_new=branch.active_schema_hash.main,
+        worker=WORKER_IDENTITY,
+    )
+    await registry.schema.load_schema(db=db, branch=branch)
+    registry.branch[branch.name] = branch
+    schema_branch = registry.schema.get_schema_branch(name=branch.name)
+
+    update_graphql_schema(branch=branch, schema_branch=schema_branch)
+
+
 async def refresh_branches(db: InfrahubDatabase) -> None:
     """Pull all the branches from the database and update the registry.
 
@@ -24,41 +84,9 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
         branches = await registry.branch_object.get_list(db=db)
         for new_branch in branches:
             if new_branch.name in registry.branch:
-                branch_registry: Branch = registry.branch[new_branch.name]
-                if (
-                    branch_registry.schema_hash
-                    and branch_registry.schema_hash.main != new_branch.active_schema_hash.main
-                ):
-                    log.info(
-                        "New hash detected",
-                        branch=new_branch.name,
-                        hash_current=branch_registry.schema_hash.main,
-                        hash_new=new_branch.active_schema_hash.main,
-                        worker=WORKER_IDENTITY,
-                    )
-                    await registry.schema.load_schema(db=db, branch=new_branch)
-                    registry.branch[new_branch.name] = new_branch
-                    schema_branch = registry.schema.get_schema_branch(name=new_branch.name)
-                    gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=new_branch, schema_branch=schema_branch)
-                    gqlm.get_graphql_schema(
-                        include_query=True,
-                        include_mutation=True,
-                        include_subscription=True,
-                        include_types=True,
-                    )
-
+                await update_branch_registry(db=db, branch=new_branch)
             else:
-                log.info("New branch detected, pulling schema", branch=new_branch.name, worker=WORKER_IDENTITY)
-                await registry.schema.load_schema(db=db, branch=new_branch)
-                registry.branch[new_branch.name] = new_branch
-                schema_branch = registry.schema.get_schema_branch(name=new_branch.name)
-                gqlm = GraphQLSchemaManager.get_manager_for_branch(branch=new_branch, schema_branch=schema_branch)
-                gqlm.get_graphql_schema(
-                    include_query=True,
-                    include_mutation=True,
-                    include_subscription=True,
-                    include_types=True,
-                )
+                await create_branch_registry(db=db, branch=new_branch)
 
         purged_branches = await registry.purge_inactive_branches(db=db, active_branches=branches)
         purged_branches.update(