infrahub-server 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

infrahub/computed_attribute/tasks.py

@@ -6,6 +6,7 @@ from infrahub_sdk.protocols import (
     CoreNode,  # noqa: TC002
     CoreTransformPython,
 )
+from infrahub_sdk.template import Jinja2Template
 from prefect import flow
 from prefect.client.orchestration import get_client
 from prefect.logging import get_run_logger
@@ -16,7 +17,6 @@ from infrahub.core.registry import registry
 from infrahub.events import BranchDeletedEvent
 from infrahub.git.repository import get_initialized_repo
 from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
-from infrahub.support.macro import MacroDefinition
 from infrahub.trigger.models import TriggerType
 from infrahub.trigger.setup import setup_triggers
 from infrahub.workflows.catalogue import (
@@ -173,15 +173,15 @@ async def update_computed_attribute_value_jinja2(
 
     await add_tags(branches=[branch_name], nodes=[obj.id], db_change=True)
 
-    macro_definition = MacroDefinition(macro=template_value)
-    my_filter = {}
-    for variable in macro_definition.variables:
+    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)
-            my_filter[variable] = getattr(attribute_property, property_value)
+            variables[variable] = getattr(attribute_property, property_value)
         elif len(components) == 3:
             relationship_name = components[0]
             property_name = components[1]
@@ -189,11 +189,11 @@ async def update_computed_attribute_value_jinja2(
             relationship = getattr(obj, relationship_name)
             try:
                 attribute_property = getattr(relationship.peer, property_name)
-                my_filter[variable] = getattr(attribute_property, property_value)
+                variables[variable] = getattr(attribute_property, property_value)
             except ValueError:
-                my_filter[variable] = ""
+                variables[variable] = ""
 
-    value = macro_definition.render(variables=my_filter)
+    value = await jinja_template.render(variables=variables)
     existing_value = getattr(obj, attribute_name).value
     if value == existing_value:
         log.debug(f"Ignoring to update {obj} with existing value on {attribute_name}={value}")

infrahub/config.py

@@ -612,6 +612,9 @@ class SecuritySettings(BaseSettings):
     oauth2_provider_settings: SecurityOAuth2ProviderSettings = Field(default_factory=SecurityOAuth2ProviderSettings)
     oidc_providers: list[OIDCProvider] = Field(default_factory=list, description="The selected OIDC providers")
     oidc_provider_settings: SecurityOIDCProviderSettings = Field(default_factory=SecurityOIDCProviderSettings)
+    restrict_untrusted_jinja2_filters: bool = Field(
+        default=True, description="Indicates if untrusted Jinja2 filters should be disallowd for computed attributes"
+    )
     _oauth2_settings: dict[str, SecurityOAuth2Settings] = PrivateAttr(default_factory=dict)
     _oidc_settings: dict[str, SecurityOIDCSettings] = PrivateAttr(default_factory=dict)
     sso_user_default_group: str | None = Field(

infrahub/core/graph/__init__.py

@@ -1 +1 @@
-GRAPH_VERSION = 22
+GRAPH_VERSION = 24

infrahub/core/migrations/graph/__init__.py

@@ -24,6 +24,8 @@ from .m019_restore_rels_to_time import Migration019
 from .m020_duplicate_edges import Migration020
 from .m021_missing_hierarchy_merge import Migration021
 from .m022_add_generate_template_attr import Migration022
+from .m023_deduplicate_cardinality_one_relationships import Migration023
+from .m024_missing_hierarchy_backfill import Migration024
 
 if TYPE_CHECKING:
     from infrahub.core.root import Root
@@ -53,7 +55,8 @@ MIGRATIONS: list[type[GraphMigration | InternalSchemaMigration | ArbitraryMigrat
     Migration020,
     Migration021,
     Migration022,
-    # Migration023,  Enable this migration once it has been tested on bigger databases
+    Migration023,
+    Migration024,
 ]
 
 

infrahub/core/migrations/graph/m024_missing_hierarchy_backfill.py

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

infrahub/core/models.py

@@ -19,6 +19,8 @@ if TYPE_CHECKING:
     from infrahub.core.schema import MainSchemaTypes
     from infrahub.core.schema.schema_branch import SchemaBranch
 
+GENERIC_ATTRIBUTES_TO_IGNORE = ["namespace", "name", "branch"]
+
 
 class NodeKind(BaseModel):
     namespace: str
@@ -270,6 +272,10 @@ class SchemaUpdateValidationResult(BaseModel):
         field_info = schema.model_fields[node_field_name]
         field_update = str(field_info.json_schema_extra.get("update"))  # type: ignore[union-attr]
 
+        # No need to execute a migration for generic nodes attributes because they are not stored in the database
+        if schema.is_generic_schema and node_field_name in GENERIC_ATTRIBUTES_TO_IGNORE:
+            return
+
         schema_path = SchemaPath(  # type: ignore[call-arg]
             schema_kind=schema.kind,
             path_type=SchemaPathType.NODE,

infrahub/core/node/__init__.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Sequence, TypeVar, overload
 
+from infrahub_sdk.template import Jinja2Template
 from infrahub_sdk.utils import is_valid_uuid
 from infrahub_sdk.uuidt import UUIDT
 
@@ -24,7 +25,6 @@ from infrahub.core.query.node import NodeCheckIDQuery, NodeCreateAllQuery, NodeD
 from infrahub.core.schema import AttributeSchema, NodeSchema, ProfileSchema, RelationshipSchema, TemplateSchema
 from infrahub.core.timestamp import Timestamp
 from infrahub.exceptions import InitializationError, NodeNotFoundError, PoolExhaustedError, ValidationError
-from infrahub.support.macro import MacroDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 
 from ...graphql.constants import KIND_GRAPHQL_FIELD_NAME
@@ -458,9 +458,9 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     ValidationError({macro: f"{macro} is missing computational_logic for macro ({attr_schema.kind})"})
                 )
                 continue
-            macro_definition = MacroDefinition(macro=attr_schema.computed_attribute.jinja2_template)
 
-            for variable in macro_definition.variables:
+            jinja_template = Jinja2Template(template=attr_schema.computed_attribute.jinja2_template)
+            for variable in jinja_template.get_variables():
                 attribute_path = schema_branch.validate_schema_path(
                     node_schema=self._schema, path=variable, allowed_path_types=allowed_path_types
                 )
@@ -487,7 +487,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     )
                     variables[variable] = attribute
 
-            content = macro_definition.render(variables=variables)
+            content = await jinja_template.render(variables=variables)
 
             generator_method_name = "_generate_attribute_default"
             if hasattr(self, f"generate_{attr_schema.name}"):

infrahub/core/node/constraints/grouped_uniqueness.py

@@ -225,16 +225,31 @@ class NodeGroupedUniquenessConstraint(NodeConstraintInterface):
             )
             violations.extend(schema_violations)
 
-        is_hfid_violated = any(violation.typ == UniquenessConstraintType.HFID for violation in violations)
+        hfid_violations = [violation for violation in violations if violation.typ == UniquenessConstraintType.HFID]
+        hfid_violation = hfid_violations[0] if len(hfid_violations) > 0 else None
 
-        for violation in violations:
-            if violation.typ == UniquenessConstraintType.STANDARD or (
-                violation.typ == UniquenessConstraintType.SUBSET_OF_HFID and not is_hfid_violated
-            ):
-                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
-                raise ValidationError(error_msg)
+        # If there are both a hfid violation and another one, in case of an upsert, we still want to update the node in case other violations are:
+        # - either on subset fields of hfid, which would be necessarily violated too
+        # - or on uniqueness constraints with a matching node id being the id of the hfid violation
 
         for violation in violations:
             if violation.typ == UniquenessConstraintType.HFID:
-                error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
-                raise HFIDViolatedError(error_msg, matching_nodes_ids=violation.nodes_ids)
+                continue
+
+            if hfid_violation:
+                if violation.typ == UniquenessConstraintType.SUBSET_OF_HFID:
+                    continue
+
+                if (
+                    violation.typ == UniquenessConstraintType.STANDARD
+                    and len(violation.nodes_ids) == 1
+                    and next(iter(violation.nodes_ids)) == next(iter(hfid_violation.nodes_ids))
+                ):
+                    continue
+
+            error_msg = f"Violates uniqueness constraint '{'-'.join(violation.fields)}'"
+            raise ValidationError(error_msg)
+
+        if hfid_violation:
+            error_msg = f"Violates uniqueness constraint '{'-'.join(hfid_violation.fields)}'"
+            raise HFIDViolatedError(error_msg, matching_nodes_ids=hfid_violation.nodes_ids)

infrahub/core/query/ipam.py

@@ -362,7 +362,7 @@ class IPPrefixReconcileQuery(Query):
         # possible prefix: highest possible prefix length for a match
         possible_prefix_map: dict[str, int] = {}
         start_prefixlen = prefixlen if is_address else prefixlen - 1
-        for max_prefix_len in range(start_prefixlen, 0, -1):
+        for max_prefix_len in range(start_prefixlen, -1, -1):
             tmp_prefix = prefix_bin_host[:max_prefix_len]
             possible_prefix = tmp_prefix.ljust(self.ip_value.max_prefixlen, "0")
             if possible_prefix not in possible_prefix_map:

infrahub/core/schema/schema_branch.py

@@ -6,6 +6,8 @@ from collections import defaultdict
 from itertools import chain, combinations
 from typing import Any
 
+from infrahub_sdk.template import Jinja2Template
+from infrahub_sdk.template.exceptions import JinjaTemplateError, JinjaTemplateOperationViolationError
 from infrahub_sdk.topological_sort import DependencyCycleExistsError, topological_sort
 from infrahub_sdk.utils import compare_lists, deep_merge_dict, duplicates, intersection
 from typing_extensions import Self
@@ -51,7 +53,6 @@ from infrahub.core.schema.definitions.core import core_profile_schema_definition
 from infrahub.core.validators import CONSTRAINT_VALIDATOR_MAP
 from infrahub.exceptions import SchemaNotFoundError, ValidationError
 from infrahub.log import get_logger
-from infrahub.support.macro import MacroDefinition
 from infrahub.types import ATTRIBUTE_TYPES
 from infrahub.utils import format_label
 from infrahub.visuals import select_color
@@ -1037,14 +1038,22 @@ class SchemaBranch:
                 | SchemaElementPathType.REL_ONE_MANDATORY_ATTR_WITH_PROP
                 | SchemaElementPathType.REL_ONE_ATTR_WITH_PROP
             )
+
+            jinja_template = Jinja2Template(template=attribute.computed_attribute.jinja2_template)
             try:
-                macro = MacroDefinition(macro=attribute.computed_attribute.jinja2_template)
-            except ValueError as exc:
+                variables = jinja_template.get_variables()
+                jinja_template.validate(restricted=config.SETTINGS.security.restrict_untrusted_jinja2_filters)
+            except JinjaTemplateOperationViolationError as exc:
+                raise ValueError(
+                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template: {exc.message}"
+                ) from exc
+
+            except JinjaTemplateError as exc:
                 raise ValueError(
-                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template"
+                    f"{node.kind}: Attribute {attribute.name!r} is assigned by a jinja2 template, but has an invalid template: : {exc.message}"
                 ) from exc
 
-            for variable in macro.variables:
+            for variable in variables:
                 try:
                     schema_path = self.validate_schema_path(
                         node_schema=node, path=variable, allowed_path_types=allowed_path_types

infrahub/git/integrator.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 import hashlib
 import importlib
 import sys
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
-import jinja2
 import ujson
 import yaml
 from infrahub_sdk import InfrahubClient  # noqa: TC002
@@ -28,6 +28,8 @@ from infrahub_sdk.schema.repository import (
     InfrahubPythonTransformConfig,
     InfrahubRepositoryConfig,
 )
+from infrahub_sdk.template import Jinja2Template
+from infrahub_sdk.template.exceptions import JinjaTemplateError
 from infrahub_sdk.utils import compare_lists
 from infrahub_sdk.yaml import SchemaFile
 from prefect import flow, task
@@ -1057,14 +1059,14 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
 
         self.validate_location(commit=commit, worktree_directory=commit_worktree.directory, file_path=location)
 
+        jinja2_template = Jinja2Template(template=Path(location), template_directory=Path(commit_worktree.directory))
         try:
-            templateLoader = jinja2.FileSystemLoader(searchpath=commit_worktree.directory)
-            templateEnv = jinja2.Environment(loader=templateLoader, trim_blocks=True, lstrip_blocks=True)
-            template = templateEnv.get_template(location)
-            return template.render(**data)
-        except Exception as exc:
+            return await jinja2_template.render(variables=data)
+        except JinjaTemplateError as exc:
             log.error(str(exc), exc_info=True)
-            raise TransformError(repository_name=self.name, commit=commit, location=location, message=str(exc)) from exc
+            raise TransformError(
+                repository_name=self.name, commit=commit, location=location, message=exc.message
+            ) from exc
 
     @task(name="python-check-execute", task_run_name="Execute Python Check", cache_policy=NONE)  # type: ignore[arg-type]
     async def execute_python_check(

infrahub/menu/repository.py

@@ -20,9 +20,9 @@ class MenuRepository:
         async def add_children(menu_item: MenuItemDict, menu_node: CoreMenuItem) -> MenuItemDict:
             children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
             for child_id, child_node in children.items():
-                child_menu_item = menu_by_ids[child_id]
-                child = await add_children(child_menu_item, child_node)
-                menu_item.children[str(child.identifier)] = child
+                if child_menu_item := menu_by_ids.get(child_id):
+                    child = await add_children(child_menu_item, child_node)
+                    menu_item.children[str(child.identifier)] = child
             return menu_item
 
         for menu_node in nodes.values():
@@ -33,9 +33,9 @@ class MenuRepository:
 
             children = await menu_node.children.get_peers(db=self.db, peer_type=CoreMenuItem)
             for child_id, child_node in children.items():
-                child_menu_item = menu_by_ids[child_id]
-                child = await add_children(child_menu_item, child_node)
-                menu_item.children[str(child.identifier)] = child
+                if child_menu_item := menu_by_ids.get(child_id):
+                    child = await add_children(child_menu_item, child_node)
+                    menu_item.children[str(child.identifier)] = child
 
             menu.data[str(menu_item.identifier)] = menu_item
 

infrahub_sdk/client.py

@@ -281,7 +281,7 @@ class InfrahubClient(BaseClient):
         self.schema = InfrahubSchema(self)
         self.branch = InfrahubBranchManager(self)
         self.object_store = ObjectStore(self)
-        self.store = NodeStore()
+        self.store = NodeStore(default_branch=self.default_branch)
         self.task = InfrahubTaskManager(self)
         self.concurrent_execution_limit = asyncio.Semaphore(self.max_concurrent_execution)
         self._request_method: AsyncRequester = self.config.requester or self._default_request_method
@@ -840,11 +840,11 @@ class InfrahubClient(BaseClient):
         if populate_store:
             for node in nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
         return nodes
 
     def clone(self) -> InfrahubClient:
@@ -1529,7 +1529,7 @@ class InfrahubClientSync(BaseClient):
         self.schema = InfrahubSchemaSync(self)
         self.branch = InfrahubBranchManagerSync(self)
         self.object_store = ObjectStoreSync(self)
-        self.store = NodeStoreSync()
+        self.store = NodeStoreSync(default_branch=self.default_branch)
         self.task = InfrahubTaskManagerSync(self)
         self._request_method: SyncRequester = self.config.sync_requester or self._default_request_method
         self.group_context = InfrahubGroupContextSync(self)
@@ -1997,11 +1997,11 @@ class InfrahubClientSync(BaseClient):
         if populate_store:
             for node in nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
             related_nodes = list(set(related_nodes))
             for node in related_nodes:
                 if node.id:
-                    self.store.set(key=node.id, node=node)
+                    self.store.set(node=node)
         return nodes
 
     @overload

infrahub_sdk/ctl/cli_commands.py

@@ -9,7 +9,6 @@ import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, Optional
 
-import jinja2
 import typer
 import ujson
 from rich.console import Console
@@ -18,7 +17,6 @@ from rich.logging import RichHandler
 from rich.panel import Panel
 from rich.pretty import Pretty
 from rich.table import Table
-from rich.traceback import Traceback
 
 from .. import __version__ as sdk_version
 from ..async_typer import AsyncTyper
@@ -31,7 +29,7 @@ from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.generator import run as run_generator
 from ..ctl.menu import app as menu_app
 from ..ctl.object import app as object_app
-from ..ctl.render import list_jinja2_transforms
+from ..ctl.render import list_jinja2_transforms, print_template_errors
 from ..ctl.repository import app as repository_app
 from ..ctl.repository import get_repository_config
 from ..ctl.schema import app as schema_app
@@ -44,8 +42,9 @@ from ..ctl.utils import (
 )
 from ..ctl.validate import app as validate_app
 from ..exceptions import GraphQLError, ModuleImportError
-from ..jinja2 import identify_faulty_jinja_code
 from ..schema import MainSchemaTypesAll, SchemaRoot
+from ..template import Jinja2Template
+from ..template.exceptions import JinjaTemplateError
 from ..utils import get_branch, write_to_file
 from ..yaml import SchemaFile
 from .exporter import dump
@@ -168,43 +167,28 @@ async def run(
         raise typer.Abort(f"Unable to Load the method {method} in the Python script at {script}")
 
     client = initialize_client(
-        branch=branch, timeout=timeout, max_concurrent_execution=concurrent, identifier=module_name
+        branch=branch,
+        timeout=timeout,
+        max_concurrent_execution=concurrent,
+        identifier=module_name,
     )
     func = getattr(module, method)
     await func(client=client, log=log, branch=branch, **variables_dict)
 
 
-def render_jinja2_template(template_path: Path, variables: dict[str, str], data: dict[str, Any]) -> str:
-    if not template_path.is_file():
-        console.print(f"[red]Unable to locate the template at {template_path}")
-        raise typer.Exit(1)
-
-    templateLoader = jinja2.FileSystemLoader(searchpath=".")
-    templateEnv = jinja2.Environment(loader=templateLoader, trim_blocks=True, lstrip_blocks=True)
-    template = templateEnv.get_template(str(template_path))
-
+async def render_jinja2_template(template_path: Path, variables: dict[str, Any], data: dict[str, Any]) -> str:
+    variables["data"] = data
+    jinja_template = Jinja2Template(template=Path(template_path), template_directory=Path())
     try:
-        rendered_tpl = template.render(**variables, data=data)  # type: ignore[arg-type]
-    except jinja2.TemplateSyntaxError as exc:
-        console.print("[red]Syntax Error detected on the template")
-        console.print(f"[yellow]  {exc}")
-        raise typer.Exit(1) from exc
-
-    except jinja2.UndefinedError as exc:
-        console.print("[red]An error occurred while rendering the jinja template")
-        traceback = Traceback(show_locals=False)
-        errors = identify_faulty_jinja_code(traceback=traceback)
-        for frame, syntax in errors:
-            console.print(f"[yellow]{frame.filename} on line {frame.lineno}\n")
-            console.print(syntax)
-        console.print("")
-        console.print(traceback.trace.stacks[0].exc_value)
+        rendered_tpl = await jinja_template.render(variables=variables)
+    except JinjaTemplateError as exc:
+        print_template_errors(error=exc, console=console)
         raise typer.Exit(1) from exc
 
     return rendered_tpl
 
 
-def _run_transform(
+async def _run_transform(
     query_name: str,
     variables: dict[str, Any],
     transform_func: Callable,
@@ -227,7 +211,11 @@ def _run_transform(
 
     try:
         response = execute_graphql_query(
-            query=query_name, variables_dict=variables, branch=branch, debug=debug, repository_config=repository_config
+            query=query_name,
+            variables_dict=variables,
+            branch=branch,
+            debug=debug,
+            repository_config=repository_config,
         )
 
         # TODO: response is a dict and can't be printed to the console in this way.
@@ -249,7 +237,7 @@ def _run_transform(
         raise typer.Abort()
 
     if asyncio.iscoroutinefunction(transform_func):
-        output = asyncio.run(transform_func(response))
+        output = await transform_func(response)
     else:
         output = transform_func(response)
     return output
@@ -257,7 +245,7 @@ def _run_transform(
 
 @app.command(name="render")
 @catch_exception(console=console)
-def render(
+async def render(
     transform_name: str = typer.Argument(default="", help="Name of the Python transformation", show_default=False),
     variables: Optional[list[str]] = typer.Argument(
         None, help="Variables to pass along with the query. Format key=value key=value."
@@ -289,7 +277,7 @@ def render(
     transform_func = functools.partial(render_jinja2_template, transform_config.template_path, variables_dict)
 
     # Query GQL and run the transform
-    result = _run_transform(
+    result = await _run_transform(
         query_name=transform_config.query,
         variables=variables_dict,
         transform_func=transform_func,
@@ -410,7 +398,10 @@ def version() -> None:
 
 @app.command(name="info")
 @catch_exception(console=console)
-def info(detail: bool = typer.Option(False, help="Display detailed information."), _: str = CONFIG_PARAM) -> None:  # noqa: PLR0915
+def info(  # noqa: PLR0915
+    detail: bool = typer.Option(False, help="Display detailed information."),
+    _: str = CONFIG_PARAM,
+) -> None:
     """Display the status of the Python SDK."""
 
     info: dict[str, Any] = {
@@ -476,10 +467,14 @@ def info(detail: bool = typer.Option(False, help="Display detailed information."
         infrahub_info = Table(show_header=False, box=None)
         if info["user_info"]:
             infrahub_info.add_row("User:", info["user_info"]["AccountProfile"]["display_label"])
-            infrahub_info.add_row("Description:", info["user_info"]["AccountProfile"]["description"]["value"])
+            infrahub_info.add_row(
+                "Description:",
+                info["user_info"]["AccountProfile"]["description"]["value"],
+            )
             infrahub_info.add_row("Status:", info["user_info"]["AccountProfile"]["status"]["label"])
             infrahub_info.add_row(
-                "Number of Groups:", str(info["user_info"]["AccountProfile"]["member_of_groups"]["count"])
+                "Number of Groups:",
+                str(info["user_info"]["AccountProfile"]["member_of_groups"]["count"]),
             )
 
             if groups := info["groups"]:

infrahub_sdk/ctl/render.py

@@ -1,6 +1,12 @@
 from rich.console import Console
 
 from ..schema.repository import InfrahubRepositoryConfig
+from ..template.exceptions import (
+    JinjaTemplateError,
+    JinjaTemplateNotFoundError,
+    JinjaTemplateSyntaxError,
+    JinjaTemplateUndefinedError,
+)
 
 
 def list_jinja2_transforms(config: InfrahubRepositoryConfig) -> None:
@@ -9,3 +15,36 @@ def list_jinja2_transforms(config: InfrahubRepositoryConfig) -> None:
 
     for transform in config.jinja2_transforms:
         console.print(f"{transform.name} ({transform.template_path})")
+
+
+def print_template_errors(error: JinjaTemplateError, console: Console) -> None:
+    if isinstance(error, JinjaTemplateNotFoundError):
+        console.print("[red]An error occurred while rendering the jinja template")
+        console.print("")
+        if error.base_template:
+            console.print(f"Base template: [yellow]{error.base_template}")
+        console.print(f"Missing template: [yellow]{error.filename}")
+        return
+
+    if isinstance(error, JinjaTemplateUndefinedError):
+        console.print("[red]An error occurred while rendering the jinja template")
+        for current_error in error.errors:
+            console.print(f"[yellow]{current_error.frame.filename} on line {current_error.frame.lineno}\n")
+            console.print(current_error.syntax)
+        console.print("")
+        console.print(error.message)
+        return
+
+    if isinstance(error, JinjaTemplateSyntaxError):
+        console.print("[red]A syntax error was encountered within the template")
+        console.print("")
+        if error.filename:
+            console.print(f"Filename: [yellow]{error.filename}")
+        console.print(f"Line number: [yellow]{error.lineno}")
+        console.print()
+        console.print(error.message)
+        return
+
+    console.print("[red]An error occurred while rendering the jinja template")
+    console.print("")
+    console.print(f"[yellow]{error.message}")

infrahub_sdk/exceptions.py

@@ -69,12 +69,12 @@ class ModuleImportError(Error):
 class NodeNotFoundError(Error):
     def __init__(
         self,
-        node_type: str,
         identifier: Mapping[str, list[str]],
         message: str = "Unable to find the node in the database.",
         branch_name: str | None = None,
+        node_type: str | None = None,
     ):
-        self.node_type = node_type
+        self.node_type = node_type or "unknown"
         self.identifier = identifier
         self.branch_name = branch_name
 
@@ -88,6 +88,10 @@ class NodeNotFoundError(Error):
         """
 
 
+class NodeInvalidError(NodeNotFoundError):
+    pass
+
+
 class ResourceNotDefinedError(Error):
     """Raised when trying to access a resource that hasn't been defined."""