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

infrahub/git/base.py

@@ -17,13 +17,16 @@ from pydantic import BaseModel, ConfigDict, Field
 from pydantic import ValidationError as PydanticValidationError
 
 from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
+from infrahub.core.constants import InfrahubKind, RepositoryOperationalStatus, RepositorySyncStatus
 from infrahub.core.registry import registry
 from infrahub.exceptions import (
     CommitNotFoundError,
     FileOutOfRepositoryError,
+    RepositoryConnectionError,
+    RepositoryCredentialsError,
     RepositoryError,
     RepositoryFileNotFoundError,
+    RepositoryInvalidBranchError,
     RepositoryInvalidFileSystemError,
 )
 from infrahub.git.constants import BRANCHES_DIRECTORY_NAME, COMMITS_DIRECTORY_NAME, TEMPORARY_DIRECTORY_NAME
@@ -200,6 +203,54 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         """Return the path to the directory where the temp worktrees of all the commits pending validation are stored."""
         return self.directory_root / TEMPORARY_DIRECTORY_NAME
 
+    async def _update_operational_status(self, status: RepositoryOperationalStatus) -> None:
+        update_status = """
+        mutation UpdateRepositoryStatus(
+            $repo_id: String!,
+            $status: String!,
+        ) {
+            CoreGenericRepositoryUpdate(
+                data: {
+                    id: $repo_id,
+                    operational_status: { value: $status },
+                }
+            ) {
+                ok
+            }
+        }
+        """
+
+        await self.sdk.execute_graphql(
+            branch_name=self.infrahub_branch_name or registry.default_branch,
+            query=update_status,
+            variables={"repo_id": str(self.id), "status": status.value},
+            tracker="mutation-repository-update-operational-status",
+        )
+
+    async def _update_sync_status(self, branch_name: str, status: RepositorySyncStatus) -> None:
+        update_status = """
+        mutation UpdateRepositoryStatus(
+            $repo_id: String!,
+            $status: String!,
+        ) {
+            CoreGenericRepositoryUpdate(
+                data: {
+                    id: $repo_id,
+                    sync_status: { value: $status },
+                }
+            ) {
+                ok
+            }
+        }
+        """
+
+        await self.sdk.execute_graphql(
+            branch_name=branch_name,
+            query=update_status,
+            variables={"repo_id": str(self.id), "status": status.value},
+            tracker="mutation-repository-update-admin-status",
+        )
+
     def get_git_repo_main(self) -> Repo:
         """Return Git Repo object of the main repository.
 
@@ -340,7 +391,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
             repo = Repo.clone_from(self.location, self.directory_default)
             repo.git.checkout(checkout_ref or self.default_branch)
         except GitCommandError as exc:
-            self._raise_enriched_error(error=exc)
+            await self._raise_enriched_error(error=exc)
 
         self.has_origin = True
 
@@ -572,7 +623,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
             try:
                 br_repo.remotes.origin.pull(branch_name)
             except GitCommandError as exc:
-                self._raise_enriched_error(error=exc, branch_name=branch_name)
+                await self._raise_enriched_error(error=exc, branch_name=branch_name)
             self.create_commit_worktree(str(br_repo.head.reference.commit))
             log.debug(
                 f"Branch {branch_name} created in Git, tracking remote branch {remote_branch[0]}.",
@@ -668,7 +719,9 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         try:
             repo.remotes.origin.fetch()
         except GitCommandError as exc:
-            self._raise_enriched_error(error=exc)
+            await self._raise_enriched_error(error=exc)
+
+        await self._update_operational_status(status=RepositoryOperationalStatus.ONLINE)
 
         return True
 
@@ -765,7 +818,7 @@ class InfrahubRepositoryBase(BaseModel, ABC):
                 commit_before = str(repo.head.commit)
                 repo.remotes.origin.pull(branch_name)
             except GitCommandError as exc:
-                self._raise_enriched_error(error=exc, branch_name=branch_name)
+                await self._raise_enriched_error(error=exc, branch_name=branch_name)
 
             commit_after = str(repo.head.commit)
 
@@ -862,37 +915,41 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         except GitCommandError as exc:
             cls._raise_enriched_error_static(name=name, location=url, error=exc)
 
-    def _raise_enriched_error(self, error: GitCommandError, branch_name: str | None = None) -> NoReturn:
-        self._raise_enriched_error_static(
-            error=error, name=self.name, location=self.location, branch_name=branch_name or self.default_branch
-        )
+    async def _raise_enriched_error(self, error: GitCommandError, branch_name: str | None = None) -> NoReturn:
+        try:
+            self._raise_enriched_error_static(
+                error=error, name=self.name, location=self.location, branch_name=branch_name or self.default_branch
+            )
+        except RepositoryError as exc:
+            await self._update_operational_status(
+                status={
+                    RepositoryConnectionError: RepositoryOperationalStatus.ERROR_CONNECTION,
+                    RepositoryCredentialsError: RepositoryOperationalStatus.ERROR_CRED,
+                }.get(type(exc), RepositoryOperationalStatus.ERROR)
+            )
+            raise
 
     @staticmethod
     def _raise_enriched_error_static(
         error: GitCommandError, name: str, location: str, branch_name: str | None = None
     ) -> NoReturn:
         if "Repository not found" in error.stderr or "does not appear to be a git" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"Unable to clone the repository {name}, please check the address and the credential",
-            ) from error
+            raise RepositoryConnectionError(identifier=name) from error
 
         if "error: pathspec" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"The branch {branch_name} isn't a valid branch for the repository {name} at {location}.",
-            ) from error
+            raise RepositoryInvalidBranchError(identifier=name, branch_name=branch_name, location=location) from error
 
         if "SSL certificate problem" in error.stderr or "server certificate verification failed" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"SSL verification failed for {name}, please validate the certificate chain.",
+            raise RepositoryConnectionError(
+                identifier=name, message=f"SSL verification failed for {name}, please validate the certificate chain."
             ) from error
 
         if "authentication failed for" in error.stderr.lower():
-            raise RepositoryError(
-                identifier=name,
-                message=f"Authentication failed for {name}, please validate the credentials.",
+            raise RepositoryCredentialsError(identifier=name) from error
+
+        if "fatal: could not read Username for" in error.stderr and "terminal prompts disable" in error.stderr:
+            raise RepositoryCredentialsError(
+                identifier=name, message=f"Unable to correctly lookup credentials for repository {name} ({location})."
             ) from error
 
         if any(err in error.stderr for err in ("Need to specify how to reconcile", "because you have unmerged files")):
@@ -901,12 +958,6 @@ class InfrahubRepositoryBase(BaseModel, ABC):
                 message=f"Unable to pull the branch {branch_name} for repository {name}, there are conflicts that must be resolved.",
             ) from error
 
-        if "fatal: could not read Username for" in error.stderr and "terminal prompts disable" in error.stderr:
-            raise RepositoryError(
-                identifier=name,
-                message=f"Unable to correctly lookup credentials for repository {name} ({location}).",
-            ) from error
-
         raise RepositoryError(identifier=name, message=error.stderr) from error
 
     def _get_mapped_remote_branch(self, branch_name: str) -> str:

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
@@ -212,30 +214,6 @@ class InfrahubRepositoryIntegrator(InfrahubRepositoryBase):
             )
         )
 
-    async def _update_sync_status(self, branch_name: str, status: RepositorySyncStatus) -> None:
-        update_status = """
-        mutation UpdateRepositoryStatus(
-            $repo_id: String!,
-            $status: String!,
-            ) {
-            CoreGenericRepositoryUpdate(
-                data: {
-                    id: $repo_id,
-                    sync_status: { value: $status },
-                }
-            ) {
-                ok
-            }
-        }
-        """
-
-        await self.sdk.execute_graphql(
-            branch_name=branch_name,
-            query=update_status,
-            variables={"repo_id": str(self.id), "status": status.value},
-            tracker="mutation-repository-update-admin-status",
-        )
-
     @task(name="import-jinja2-tansforms", task_run_name="Import Jinja2 transform", cache_policy=NONE)  # type: ignore[arg-type]
     async def import_jinja2_transforms(
         self,
@@ -1081,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/trigger/tasks.py

@@ -14,23 +14,24 @@ from .setup import setup_triggers
 
 @flow(name="trigger-configure-all", flow_run_name="Configure all triggers")
 async def trigger_configure_all(service: InfrahubServices) -> None:
-    webhook_trigger = await gather_trigger_webhook(db=service.database)
-    computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
-    (
-        computed_attribute_python_triggers,
-        computed_attribute_python_query_triggers,
-    ) = await gather_trigger_computed_attribute_python(db=service.database)
+    async with service.database.start_session() as db:
+        webhook_trigger = await gather_trigger_webhook(db=db)
+        computed_attribute_j2_triggers = await gather_trigger_computed_attribute_jinja2()
+        (
+            computed_attribute_python_triggers,
+            computed_attribute_python_query_triggers,
+        ) = await gather_trigger_computed_attribute_python(db=db)
 
-    triggers = (
-        computed_attribute_j2_triggers
-        + computed_attribute_python_triggers
-        + computed_attribute_python_query_triggers
-        + builtin_triggers
-        + webhook_trigger
-    )
-
-    async with get_client(sync_client=False) as prefect_client:
-        await setup_triggers(
-            client=prefect_client,
-            triggers=triggers,
+        triggers = (
+            computed_attribute_j2_triggers
+            + computed_attribute_python_triggers
+            + computed_attribute_python_query_triggers
+            + builtin_triggers
+            + webhook_trigger
         )
+
+        async with get_client(sync_client=False) as prefect_client:
+            await setup_triggers(
+                client=prefect_client,
+                triggers=triggers,
+            )

infrahub/workflows/utils.py

@@ -15,7 +15,8 @@ from .constants import TAG_NAMESPACE, WorkflowTag
 if TYPE_CHECKING:
     import logging
 
-    from infrahub.services import InfrahubServices
+    from infrahub.database import InfrahubDatabase
+    from infrahub.services import InfrahubComponent
 
 
 async def add_tags(
@@ -56,7 +57,7 @@ async def add_related_node_tag(node_id: str) -> None:
 
 
 async def wait_for_schema_to_converge(
-    branch_name: str, service: InfrahubServices, log: logging.Logger | logging.LoggerAdapter
+    branch_name: str, component: InfrahubComponent, db: InfrahubDatabase, log: logging.Logger | logging.LoggerAdapter
 ) -> None:
     has_converged = False
     branch_id = branch_name
@@ -67,7 +68,7 @@ async def wait_for_schema_to_converge(
     max_iterations = delay * 5 * 30
     iteration = 0
     while not has_converged:
-        workers = await service.component.list_workers(branch=branch_id, schema_hash=True)
+        workers = await component.list_workers(branch=branch_id, schema_hash=True)
 
         hashes = {worker.schema_hash for worker in workers if worker.active}
         if len(hashes) == 1:
@@ -79,8 +80,7 @@ async def wait_for_schema_to_converge(
             log.warning(
                 f"Schema had not converged after {delay * iteration:.2f} seconds, refreshing schema on local worker manually"
             )
-            async with service.database.start_session() as db:
-                await refresh_branches(db=db)
+            await refresh_branches(db=db)
             return
 
         iteration += 1

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."""
 

infrahub_sdk/generator.py

@@ -137,7 +137,7 @@ class InfrahubGenerator:
 
         for node in self._nodes + self._related_nodes:
             if node.id:
-                self._init_client.store.set(key=node.id, node=node)
+                self._init_client.store.set(node=node)
 
     @abstractmethod
     async def generate(self, data: dict) -> None: