infrahub-server 1.2.5__py3-none-any.whl → 1.2.7__py3-none-any.whl

infrahub/cli/db.py

@@ -54,12 +54,14 @@ from infrahub.services.adapters.message_bus.local import BusSimulator
 from infrahub.services.adapters.workflow.local import WorkflowLocalExecution
 
 from .constants import ERROR_BADGE, FAILED_BADGE, SUCCESS_BADGE
+from .patch import patch_app
 
 if TYPE_CHECKING:
     from infrahub.cli.context import CliContext
     from infrahub.database import InfrahubDatabase
 
 app = AsyncTyper()
+app.add_typer(patch_app, name="patch")
 
 PERMISSIONS_AVAILABLE = ["read", "write", "admin"]
 

infrahub/cli/patch.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import typer
+from infrahub_sdk.async_typer import AsyncTyper
+from rich import print as rprint
+
+from infrahub import config
+from infrahub.patch.edge_adder import PatchPlanEdgeAdder
+from infrahub.patch.edge_deleter import PatchPlanEdgeDeleter
+from infrahub.patch.edge_updater import PatchPlanEdgeUpdater
+from infrahub.patch.plan_reader import PatchPlanReader
+from infrahub.patch.plan_writer import PatchPlanWriter
+from infrahub.patch.queries.base import PatchQuery
+from infrahub.patch.runner import (
+    PatchPlanEdgeDbIdTranslator,
+    PatchRunner,
+)
+from infrahub.patch.vertex_adder import PatchPlanVertexAdder
+from infrahub.patch.vertex_deleter import PatchPlanVertexDeleter
+from infrahub.patch.vertex_updater import PatchPlanVertexUpdater
+
+from .constants import ERROR_BADGE, SUCCESS_BADGE
+
+if TYPE_CHECKING:
+    from infrahub.cli.context import CliContext
+    from infrahub.database import InfrahubDatabase
+
+
+patch_app = AsyncTyper(help="Commands for planning, applying, and reverting database patches")
+
+
+def get_patch_runner(db: InfrahubDatabase) -> PatchRunner:
+    return PatchRunner(
+        plan_writer=PatchPlanWriter(),
+        plan_reader=PatchPlanReader(),
+        edge_db_id_translator=PatchPlanEdgeDbIdTranslator(),
+        vertex_adder=PatchPlanVertexAdder(db=db),
+        vertex_deleter=PatchPlanVertexDeleter(db=db),
+        vertex_updater=PatchPlanVertexUpdater(db=db),
+        edge_adder=PatchPlanEdgeAdder(db=db),
+        edge_deleter=PatchPlanEdgeDeleter(db=db),
+        edge_updater=PatchPlanEdgeUpdater(db=db),
+    )
+
+
+@patch_app.command(name="plan")
+async def plan_patch_cmd(
+    ctx: typer.Context,
+    patch_path: str = typer.Argument(
+        help="Path to the file containing the PatchQuery instance to run. Use Python-style dot paths, such as infrahub.cli.patch.queries.base"
+    ),
+    patch_plans_dir: Path = typer.Option(Path("infrahub-patches"), help="Path to patch plans directory"),  # noqa: B008
+    apply: bool = typer.Option(False, help="Apply the patch immediately after creating it"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Create a plan for a given patch and save it in the patch plans directory to be applied/reverted"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    patch_module = importlib.import_module(patch_path)
+    patch_query_class = None
+    patch_query_class_count = 0
+    for _, cls in inspect.getmembers(patch_module, inspect.isclass):
+        if issubclass(cls, PatchQuery) and cls is not PatchQuery:
+            patch_query_class = cls
+            patch_query_class_count += 1
+
+    patch_query_path = f"{PatchQuery.__module__}.{PatchQuery.__name__}"
+    if patch_query_class is None:
+        rprint(f"{ERROR_BADGE} No subclass of {patch_query_path} found in {patch_path}")
+        raise typer.Exit(1)
+    if patch_query_class_count > 1:
+        rprint(
+            f"{ERROR_BADGE} Multiple subclasses of {patch_query_path} found in {patch_path}. Please only define one per file."
+        )
+        raise typer.Exit(1)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    patch_query_instance = patch_query_class(db=dbdriver)
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        patch_plan_dir = await patch_runner.prepare_plan(patch_query_instance, directory=Path(patch_plans_dir))
+        rprint(f"{SUCCESS_BADGE} Patch plan created at {patch_plan_dir}")
+        if apply:
+            await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+            rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="apply")
+async def apply_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Apply a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    dbdriver = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    async with dbdriver.start_session() as db:
+        patch_runner = get_patch_runner(db=db)
+        await patch_runner.apply(patch_plan_directory=patch_plan_dir)
+        rprint(f"{SUCCESS_BADGE} Patch plan successfully applied")
+
+    await dbdriver.close()
+
+
+@patch_app.command(name="revert")
+async def revert_patch_cmd(
+    ctx: typer.Context,
+    patch_plan_dir: Path = typer.Argument(help="Path to the directory containing a patch plan"),
+    config_file: str = typer.Argument("infrahub.toml", envvar="INFRAHUB_CONFIG"),
+) -> None:
+    """Revert a given patch plan"""
+    logging.getLogger("infrahub").setLevel(logging.WARNING)
+    logging.getLogger("neo4j").setLevel(logging.ERROR)
+    logging.getLogger("prefect").setLevel(logging.ERROR)
+    config.load_and_exit(config_file_name=config_file)
+
+    context: CliContext = ctx.obj
+    db = await context.init_db(retry=1)
+
+    if not patch_plan_dir.exists() or not patch_plan_dir.is_dir():
+        rprint(f"{ERROR_BADGE} patch_plan_dir must be an existing directory")
+        raise typer.Exit(1)
+
+    patch_runner = get_patch_runner(db=db)
+    await patch_runner.revert(patch_plan_directory=patch_plan_dir)
+    rprint(f"{SUCCESS_BADGE} Patch plan successfully reverted")
+
+    await db.close()

infrahub/computed_attribute/models.py

@@ -2,13 +2,16 @@ from __future__ import annotations
 
 from collections import defaultdict
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
+from infrahub_sdk.graphql import Query
 from prefect.events.schemas.automations import Automation  # noqa: TC002
 from pydantic import BaseModel, ConfigDict, Field, computed_field
 from typing_extensions import Self
 
 from infrahub.core import registry
+from infrahub.core.constants import RelationshipCardinality
+from infrahub.core.schema import AttributeSchema, NodeSchema  # noqa: TC001
 from infrahub.core.schema.schema_branch_computed import (  # noqa: TC001
     ComputedAttributeTarget,
     ComputedAttributeTriggerNode,
@@ -309,3 +312,80 @@ class ComputedAttrPythonQueryTriggerDefinition(TriggerBranchDefinition):
         )
 
         return definition
+
+
+class ComputedAttrJinja2GraphQLResponse(BaseModel):
+    node_id: str
+    computed_attribute_value: str | None
+    variables: dict[str, Any] = Field(default_factory=dict)
+
+
+class ComputedAttrJinja2GraphQL(BaseModel):
+    node_schema: NodeSchema = Field(..., description="The node kind where the computed attribute is defined")
+    attribute_schema: AttributeSchema = Field(..., description="The computed attribute")
+    variables: list[str] = Field(..., description="The list of variable names used within the computed attribute")
+
+    def render_graphql_query(self, query_filter: str, filter_id: str) -> str:
+        query_fields = self.query_fields
+        query_fields["id"] = None
+        query_fields[self.attribute_schema.name] = {"value": None}
+        query = Query(
+            name="ComputedAttributeFilter",
+            query={
+                self.node_schema.kind: {
+                    "@filters": {query_filter: filter_id},
+                    "edges": {"node": query_fields},
+                }
+            },
+        )
+
+        return query.render()
+
+    @property
+    def query_fields(self) -> dict[str, Any]:
+        output: dict[str, Any] = {}
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            if field_name in self.node_schema.attribute_names:
+                output[field_name] = {remainder: None}
+            elif field_name in self.node_schema.relationship_names:
+                related_attribute, related_value = remainder.split("__", maxsplit=1)
+                relationship = self.node_schema.get_relationship(name=field_name)
+                if relationship.cardinality == RelationshipCardinality.ONE:
+                    if field_name not in output:
+                        output[field_name] = {"node": {}}
+                    output[field_name]["node"][related_attribute] = {related_value: None}
+        return output
+
+    def parse_response(self, response: dict[str, Any]) -> list[ComputedAttrJinja2GraphQLResponse]:
+        rendered_response: list[ComputedAttrJinja2GraphQLResponse] = []
+        if kind_payload := response.get(self.node_schema.kind):
+            edges = kind_payload.get("edges", [])
+            for node in edges:
+                if node_response := self.to_node_response(node_dict=node):
+                    rendered_response.append(node_response)
+        return rendered_response
+
+    def to_node_response(self, node_dict: dict[str, Any]) -> ComputedAttrJinja2GraphQLResponse | None:
+        if node := node_dict.get("node"):
+            node_id = node.get("id")
+        else:
+            return None
+
+        computed_attribute = node.get(self.attribute_schema.name, {}).get("value")
+        response = ComputedAttrJinja2GraphQLResponse(node_id=node_id, computed_attribute_value=computed_attribute)
+        for variable in self.variables:
+            field_name, remainder = variable.split("__", maxsplit=1)
+            response.variables[variable] = None
+            if field_content := node.get(field_name):
+                if field_name in self.node_schema.attribute_names:
+                    response.variables[variable] = field_content.get(remainder)
+                elif field_name in self.node_schema.relationship_names:
+                    relationship = self.node_schema.get_relationship(name=field_name)
+                    if relationship.cardinality == RelationshipCardinality.ONE:
+                        related_attribute, related_value = remainder.split("__", maxsplit=1)
+                        node_content = field_content.get("node") or {}
+                        related_attribute_content = node_content.get(related_attribute) or {}
+                        response.variables[variable] = related_attribute_content.get(related_value)
+
+        return response

infrahub/computed_attribute/tasks.py

@@ -2,10 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from infrahub_sdk.protocols import (
-    CoreNode,  # noqa: TC002
-    CoreTransformPython,
-)
+from infrahub_sdk.protocols import CoreTransformPython
 from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.client.orchestration import get_client
@@ -28,9 +25,7 @@ from infrahub.workflows.catalogue import (
 from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
 
 from .gather import gather_trigger_computed_attribute_jinja2, gather_trigger_computed_attribute_python
-from .models import (
-    PythonTransformTarget,
-)
+from .models import ComputedAttrJinja2GraphQL, ComputedAttrJinja2GraphQLResponse, PythonTransformTarget
 
 if TYPE_CHECKING:
     from infrahub.core.schema.computed_attribute import ComputedAttribute
@@ -167,49 +162,33 @@ async def trigger_update_python_computed_attributes(
     flow_run_name="Update value for computed attribute {attribute_name}",
 )
 async def update_computed_attribute_value_jinja2(
-    branch_name: str, obj: CoreNode, attribute_name: str, template_value: str, service: InfrahubServices
+    branch_name: str,
+    obj: ComputedAttrJinja2GraphQLResponse,
+    node_kind: str,
+    attribute_name: str,
+    template: Jinja2Template,
+    service: InfrahubServices,
 ) -> None:
     log = get_run_logger()
 
-    await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
-
-    jinja_template = Jinja2Template(template=template_value)
-    variables = {}
-    for variable in jinja_template.get_variables():
-        components = variable.split("__")
-        if len(components) == 2:
-            property_name = components[0]
-            property_value = components[1]
-            attribute_property = getattr(obj, property_name)
-            variables[variable] = getattr(attribute_property, property_value)
-        elif len(components) == 3:
-            relationship_name = components[0]
-            property_name = components[1]
-            property_value = components[2]
-            relationship = getattr(obj, relationship_name)
-            try:
-                attribute_property = getattr(relationship.peer, property_name)
-                variables[variable] = getattr(attribute_property, property_value)
-            except ValueError:
-                variables[variable] = ""
-
-    value = await jinja_template.render(variables=variables)
-    existing_value = getattr(obj, attribute_name).value
-    if value == existing_value:
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    value = await template.render(variables=obj.variables)
+    if value == obj.computed_attribute_value:
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")
         return
 
     await service.client.execute_graphql(
         query=UPDATE_ATTRIBUTE,
         variables={
-            "id": obj.id,
-            "kind": obj.get_kind(),
+            "id": obj.node_id,
+            "kind": node_kind,
             "attribute": attribute_name,
             "value": value,
         },
         branch_name=branch_name,
     )
-    log.info(f"Updating computed attribute {obj.get_kind()}.{attribute_name}='{value}' ({obj.id})")
+    log.info(f"Updating computed attribute {node_kind}.{attribute_name}='{value}' ({obj.node_id})")
 
 
 @flow(
@@ -235,41 +214,43 @@ async def process_jinja2(
         branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
     )
     schema_branch = registry.schema.get_schema_branch(name=target_branch_schema)
-    await service.client.schema.all(branch=branch_name, refresh=True, schema_hash=schema_branch.get_hash())
-
+    node_schema = schema_branch.get_node(name=computed_attribute_kind, duplicate=False)
     computed_macros = [
         attrib
         for attrib in schema_branch.computed_attributes.get_impacted_jinja2_targets(kind=node_kind, updates=updates)
         if attrib.kind == computed_attribute_kind and attrib.attribute.name == computed_attribute_name
     ]
     for computed_macro in computed_macros:
-        found: list[CoreNode] = []
+        found: list[ComputedAttrJinja2GraphQLResponse] = []
+        template_string = "n/a"
+        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
+            template_string = computed_macro.attribute.computed_attribute.jinja2_template
+
+        jinja_template = Jinja2Template(template=template_string)
+        variables = jinja_template.get_variables()
+
+        attribute_graphql = ComputedAttrJinja2GraphQL(
+            node_schema=node_schema, attribute_schema=computed_macro.attribute, variables=variables
+        )
+
         for id_filter in computed_macro.node_filters:
-            filters = {id_filter: object_id}
-            nodes: list[CoreNode] = await service.client.filters(
-                kind=computed_macro.kind,
-                branch=branch_name,
-                prefetch_relationships=True,
-                populate_store=True,
-                **filters,
-            )
-            found.extend(nodes)
+            query = attribute_graphql.render_graphql_query(query_filter=id_filter, filter_id=object_id)
+            response = await service.client.execute_graphql(query=query, branch_name=branch_name)
+            output = attribute_graphql.parse_response(response=response)
+            found.extend(output)
 
         if not found:
             log.debug("No nodes found that requires updates")
 
-        template_string = "n/a"
-        if computed_macro.attribute.computed_attribute and computed_macro.attribute.computed_attribute.jinja2_template:
-            template_string = computed_macro.attribute.computed_attribute.jinja2_template
-
         batch = await service.client.create_batch()
         for node in found:
             batch.add(
                 task=update_computed_attribute_value_jinja2,
                 branch_name=branch_name,
                 obj=node,
+                node_kind=node_schema.kind,
                 attribute_name=computed_macro.attribute.name,
-                template_value=template_string,
+                template=jinja_template,
                 service=service,
             )
 

infrahub/core/manager.py

@@ -803,8 +803,21 @@ class NodeManager:
 
         hfid_str = " :: ".join(hfid)
 
-        if not node_schema.human_friendly_id or len(node_schema.human_friendly_id) != len(hfid):
-            raise NodeNotFoundError(branch_name=branch.name, node_type=kind_str, identifier=hfid_str)
+        if not node_schema.human_friendly_id:
+            raise NodeNotFoundError(
+                branch_name=branch.name,
+                node_type=kind_str,
+                identifier=hfid_str,
+                message=f"Unable to lookup node by HFID, schema '{node_schema.kind}' does not have a HFID defined.",
+            )
+
+        if len(node_schema.human_friendly_id) != len(hfid):
+            raise NodeNotFoundError(
+                branch_name=branch.name,
+                node_type=kind_str,
+                identifier=hfid_str,
+                message=f"Unable to lookup node by HFID, schema '{node_schema.kind}' HFID does not contain the same number of elements as {hfid}",
+            )
 
         filters = {}
         for key, item in zip(node_schema.human_friendly_id, hfid, strict=False):

infrahub/core/node/__init__.py

@@ -29,6 +29,7 @@ from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
 from ...graphql.models import OrderModel
+from ...log import get_logger
 from ..query.relationship import RelationshipDeleteAllQuery
 from ..relationship import RelationshipManager
 from ..utils import update_relationships_to
@@ -53,6 +54,8 @@ SchemaProtocol = TypeVar("SchemaProtocol")
 #  -
 # ---------------------------------------------------------------------------------------
 
+log = get_logger()
+
 
 class Node(BaseNode, metaclass=BaseNodeMeta):
     @classmethod
@@ -348,7 +351,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
             fields.pop("updated_at")
         for field_name in fields.keys():
             if field_name not in self._schema.valid_input_names:
-                errors.append(ValidationError({field_name: f"{field_name} is not a valid input for {self.get_kind()}"}))
+                log.error(f"{field_name} is not a valid input for {self.get_kind()}")
 
         # Backfill fields with the ones from the template if there's one
         await self.handle_object_template(fields=fields, db=db, errors=errors)

infrahub/core/query/ipam.py

@@ -367,9 +367,11 @@ class IPPrefixReconcileQuery(Query):
             possible_prefix = tmp_prefix.ljust(self.ip_value.max_prefixlen, "0")
             if possible_prefix not in possible_prefix_map:
                 possible_prefix_map[possible_prefix] = max_prefix_len
-        self.params["possible_prefix_and_length_list"] = [
-            [possible_prefix, max_length] for possible_prefix, max_length in possible_prefix_map.items()
-        ]
+        self.params["possible_prefix_and_length_list"] = []
+        self.params["possible_prefix_list"] = []
+        for possible_prefix, max_length in possible_prefix_map.items():
+            self.params["possible_prefix_and_length_list"].append([possible_prefix, max_length])
+            self.params["possible_prefix_list"].append(possible_prefix)
 
         namespace_query = """
         // ------------------
@@ -386,8 +388,7 @@ class IPPrefixReconcileQuery(Query):
             // ------------------
             // Get IP Prefix node by UUID
             // ------------------
-            MATCH (ip_node {uuid: $node_uuid})
-            WHERE "%(ip_kind)s" IN labels(ip_node)
+            MATCH (ip_node:%(ip_kind)s {uuid: $node_uuid})
             """ % {
                 "ip_kind": InfrahubKind.IPADDRESS
                 if isinstance(self.ip_value, IPAddressType)
@@ -487,6 +488,7 @@ class IPPrefixReconcileQuery(Query):
             -[hvr:HAS_VALUE]->(av:%(ip_prefix_attribute_kind)s)
             WHERE all(r IN relationships(parent_path) WHERE (%(branch_filter)s))
             AND av.version = $ip_version
+            AND av.binary_address IN $possible_prefix_list
             AND any(prefix_and_length IN $possible_prefix_and_length_list WHERE av.binary_address = prefix_and_length[0] AND av.prefixlen <= prefix_and_length[1])
             WITH
                 maybe_new_parent,

infrahub/core/registry.py

@@ -222,7 +222,7 @@ class Registry:
 
     async def purge_inactive_branches(
         self, db: InfrahubDatabase, active_branches: list[Branch] | None = None
-    ) -> list[str]:
+    ) -> set[str]:
         """Return a list of branches that were purged from the registry."""
         active_branches = active_branches or await self.branch_object.get_list(db=db)
         active_branch_names = [branch.name for branch in active_branches]
@@ -235,8 +235,7 @@ class Registry:
 
         purged_branches.update(self.schema.purge_inactive_branches(active_branches=active_branch_names))
         purged_branches.update(db.purge_inactive_schemas(active_branches=active_branch_names))
-
-        return sorted(purged_branches)
+        return purged_branches
 
 
 registry = Registry()

infrahub/core/schema/schema_branch.py

@@ -1909,10 +1909,8 @@ class SchemaBranch:
 
                 self.set(name=node_name, schema=node_schema)
 
-    def add_relationships_to_template(self, node: NodeSchema) -> None:
+    def add_relationships_to_template(self, node: NodeSchema | GenericSchema) -> None:
         template_schema = self.get(name=self._get_object_template_kind(node_kind=node.kind), duplicate=False)
-        if template_schema.is_generic_schema:
-            return
 
         # Remove previous relationships to account for new ones
         template_schema.relationships = [
@@ -1954,6 +1952,7 @@ class SchemaBranch:
                     label=f"{relationship.name} template".title()
                     if relationship.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT]
                     else relationship.name.title(),
+                    inherited=relationship.inherited,
                 )
             )
 
@@ -1983,9 +1982,6 @@ class SchemaBranch:
         need_template_kinds = [n.kind for n in need_templates]
 
         if node.is_generic_schema:
-            # When needing a template for a generic, we generate an empty shell mostly to make sure that schemas (including the GraphQL one) will
-            # look right. We don't really care about applying inheritance of fields as it was already processed and actual templates will have the
-            # correct attributes and relationships
             template = GenericSchema(
                 name=node.kind,
                 namespace="Template",
@@ -1994,43 +1990,44 @@ class SchemaBranch:
                 generate_profile=False,
                 branch=node.branch,
                 include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
                 attributes=[template_name_attr],
             )
 
             for used in node.used_by:
                 if used in need_template_kinds:
                     template.used_by.append(self._get_object_template_kind(node_kind=used))
+        else:
+            template = TemplateSchema(
+                name=node.kind,
+                namespace="Template",
+                label=f"Object template {node.label}",
+                description=f"Object template for {node.kind}",
+                branch=node.branch,
+                include_in_menu=False,
+                display_labels=["template_name__value"],
+                human_friendly_id=["template_name__value"],
+                uniqueness_constraints=[["template_name__value"]],
+                inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
+                default_filter="template_name__value",
+                attributes=[template_name_attr],
+                relationships=[
+                    RelationshipSchema(
+                        name="related_nodes",
+                        identifier="node__objecttemplate",
+                        peer=node.kind,
+                        kind=RelationshipKind.TEMPLATE,
+                        cardinality=RelationshipCardinality.MANY,
+                        branch=BranchSupportType.AWARE,
+                    )
+                ],
+            )
 
-            return template
-
-        template = TemplateSchema(
-            name=node.kind,
-            namespace="Template",
-            label=f"Object template {node.label}",
-            description=f"Object template for {node.kind}",
-            branch=node.branch,
-            include_in_menu=False,
-            display_labels=["template_name__value"],
-            human_friendly_id=["template_name__value"],
-            uniqueness_constraints=[["template_name__value"]],
-            inherit_from=[InfrahubKind.LINEAGESOURCE, InfrahubKind.NODE, core_template_schema.kind],
-            default_filter="template_name__value",
-            attributes=[template_name_attr],
-            relationships=[
-                RelationshipSchema(
-                    name="related_nodes",
-                    identifier="node__objecttemplate",
-                    peer=node.kind,
-                    kind=RelationshipKind.TEMPLATE,
-                    cardinality=RelationshipCardinality.MANY,
-                    branch=BranchSupportType.AWARE,
-                )
-            ],
-        )
-
-        for inherited in node.inherit_from:
-            if inherited in need_template_kinds:
-                template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
+            for inherited in node.inherit_from:
+                if inherited in need_template_kinds:
+                    template.inherit_from.append(self._get_object_template_kind(node_kind=inherited))
 
         for node_attr in node.attributes:
             if node_attr.unique or node_attr.read_only:
@@ -2038,7 +2035,7 @@ class SchemaBranch:
 
             attr = AttributeSchema(
                 optional=node_attr.optional if is_autogenerated_subtemplate else True,
-                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only", "inherited"]),
+                **node_attr.model_dump(exclude=["id", "unique", "optional", "read_only"]),
             )
             template.attributes.append(attr)
 

infrahub/database/__init__.py

@@ -394,8 +394,10 @@ class InfrahubDatabase:
             with QUERY_EXECUTION_METRICS.labels(**labels).time():
                 response = await self.run_query(query=query, params=params, name=name)
                 if response is None:
+                    span.set_attribute("rows", "empty")
                     return [], {}
                 results = [item async for item in response]
+                span.set_attribute("rows", len(results))
                 return results, response._metadata or {}
 
     async def run_query(

infrahub/graphql/manager.py

@@ -113,6 +113,16 @@ class GraphQLSchemaManager:
     def clear_cache(cls) -> None:
         cls._branch_details_by_name = {}
 
+    @classmethod
+    def purge_inactive(cls, active_branches: list[str]) -> set[str]:
+        """Return inactive branches that were purged"""
+        inactive_branches: set[str] = set()
+        for branch_name in list(cls._branch_details_by_name):
+            if branch_name not in active_branches:
+                inactive_branches.add(branch_name)
+                del cls._branch_details_by_name[branch_name]
+        return inactive_branches
+
     @classmethod
     def _cache_branch(
         cls, branch: Branch, schema_branch: SchemaBranch, schema_hash: str | None = None