infrahub-server 1.2.6__py3-none-any.whl → 1.2.8__py3-none-any.whl

infrahub/patch/runner.py

@@ -0,0 +1,254 @@
+from pathlib import Path
+
+from .edge_adder import PatchPlanEdgeAdder
+from .edge_deleter import PatchPlanEdgeDeleter
+from .edge_updater import PatchPlanEdgeUpdater
+from .models import EdgeToAdd, EdgeToDelete, EdgeToUpdate, PatchPlan, VertexToAdd, VertexToDelete, VertexToUpdate
+from .plan_reader import PatchPlanReader
+from .plan_writer import PatchPlanWriter
+from .queries.base import PatchQuery
+from .vertex_adder import PatchPlanVertexAdder
+from .vertex_deleter import PatchPlanVertexDeleter
+from .vertex_updater import PatchPlanVertexUpdater
+
+
+class PatchPlanEdgeDbIdTranslator:
+    def translate_to_db_ids(self, patch_plan: PatchPlan) -> None:
+        for edge_to_add in patch_plan.edges_to_add:
+            translated_from_id = patch_plan.get_database_id_for_added_element(abstract_id=edge_to_add.from_id)
+            edge_to_add.from_id = translated_from_id
+            translated_to_id = patch_plan.get_database_id_for_added_element(abstract_id=edge_to_add.to_id)
+            edge_to_add.to_id = translated_to_id
+
+
+class PatchRunner:
+    def __init__(
+        self,
+        plan_writer: PatchPlanWriter,
+        plan_reader: PatchPlanReader,
+        edge_db_id_translator: PatchPlanEdgeDbIdTranslator,
+        vertex_adder: PatchPlanVertexAdder,
+        vertex_updater: PatchPlanVertexUpdater,
+        vertex_deleter: PatchPlanVertexDeleter,
+        edge_adder: PatchPlanEdgeAdder,
+        edge_updater: PatchPlanEdgeUpdater,
+        edge_deleter: PatchPlanEdgeDeleter,
+    ) -> None:
+        self.plan_writer = plan_writer
+        self.plan_reader = plan_reader
+        self.edge_db_id_translator = edge_db_id_translator
+        self.vertex_adder = vertex_adder
+        self.vertex_updater = vertex_updater
+        self.vertex_deleter = vertex_deleter
+        self.edge_adder = edge_adder
+        self.edge_updater = edge_updater
+        self.edge_deleter = edge_deleter
+
+    async def prepare_plan(self, patch_query: PatchQuery, directory: Path) -> Path:
+        patch_plan = await patch_query.plan()
+        return self.plan_writer.write(patches_directory=directory, patch_plan=patch_plan)
+
+    async def apply(self, patch_plan_directory: Path) -> PatchPlan:
+        patch_plan = self.plan_reader.read(patch_plan_directory)
+        await self._apply_vertices_to_add(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._apply_edges_to_add(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        if patch_plan.vertices_to_update:
+            await self.vertex_updater.execute(vertices_to_update=patch_plan.vertices_to_update)
+        await self._apply_edges_to_delete(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._apply_vertices_to_delete(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        if patch_plan.edges_to_update:
+            await self.edge_updater.execute(edges_to_update=patch_plan.edges_to_update)
+        return patch_plan
+
+    async def _apply_vertices_to_add(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.vertices_to_add:
+            return
+        unadded_vertices = [
+            v for v in patch_plan.vertices_to_add if not patch_plan.has_element_been_added(v.identifier)
+        ]
+        try:
+            async for added_element_id_map in self.vertex_adder.execute(vertices_to_add=unadded_vertices):
+                patch_plan.added_element_db_id_map.update(added_element_id_map)
+        finally:
+            # record the added elements so that we do not double-add them if the patch is run again
+            self.plan_writer.write_added_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+            )
+
+    async def _apply_edges_to_add(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.edges_to_add:
+            return
+        self.edge_db_id_translator.translate_to_db_ids(patch_plan=patch_plan)
+        unadded_edges = [e for e in patch_plan.edges_to_add if not patch_plan.has_element_been_added(e.identifier)]
+        try:
+            async for added_element_id_map in self.edge_adder.execute(edges_to_add=unadded_edges):
+                patch_plan.added_element_db_id_map.update(added_element_id_map)
+        finally:
+            # record the added elements so that we do not double-add them if the patch is run again
+            self.plan_writer.write_added_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+            )
+
+    async def _apply_vertices_to_delete(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.vertices_to_delete:
+            return
+        try:
+            async for deleted_ids in self.vertex_deleter.execute(vertices_to_delete=patch_plan.vertices_to_delete):
+                patch_plan.deleted_db_ids |= deleted_ids
+        finally:
+            # record the deleted elements so that we know what to add if the patch is reverted
+            self.plan_writer.write_deleted_db_ids(
+                patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+            )
+
+    async def _apply_edges_to_delete(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        if not patch_plan.edges_to_delete:
+            return
+        try:
+            async for deleted_ids in self.edge_deleter.execute(edges_to_delete=patch_plan.edges_to_delete):
+                patch_plan.deleted_db_ids |= deleted_ids
+        finally:
+            # record the deleted elements so that we know what to add if the patch is reverted
+            self.plan_writer.write_deleted_db_ids(
+                patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+            )
+
+    async def revert(self, patch_plan_directory: Path) -> PatchPlan:
+        """Invert the PatchPlan to create the complement of every added/updated/deleted element and undo them"""
+        patch_plan = self.plan_reader.read(patch_plan_directory)
+        await self._revert_deleted_vertices(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._revert_deleted_edges(
+            patch_plan=patch_plan,
+            patch_plan_directory=patch_plan_directory,
+        )
+        await self._revert_added_edges(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        await self._revert_added_vertices(patch_plan=patch_plan, patch_plan_directory=patch_plan_directory)
+        vertices_to_update = [
+            VertexToUpdate(
+                db_id=vertex_update_to_revert.db_id,
+                before_props=vertex_update_to_revert.after_props,
+                after_props=vertex_update_to_revert.before_props,
+            )
+            for vertex_update_to_revert in patch_plan.vertices_to_update
+        ]
+        if vertices_to_update:
+            await self.vertex_updater.execute(vertices_to_update=vertices_to_update)
+
+        edges_to_update = [
+            EdgeToUpdate(
+                db_id=edge_update_to_revert.db_id,
+                before_props=edge_update_to_revert.after_props,
+                after_props=edge_update_to_revert.before_props,
+            )
+            for edge_update_to_revert in patch_plan.edges_to_update
+        ]
+        if edges_to_update:
+            await self.edge_updater.execute(edges_to_update=edges_to_update)
+        if patch_plan.reverted_deleted_db_id_map:
+            patch_plan.reverted_deleted_db_id_map = {}
+            self.plan_writer.write_reverted_deleted_db_id_map(
+                patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.reverted_deleted_db_id_map
+            )
+        return patch_plan
+
+    async def _revert_added_vertices(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        vertices_to_delete = [
+            VertexToDelete(
+                db_id=patch_plan.get_database_id_for_added_element(abstract_id=vertex_add_to_revert.identifier),
+                labels=vertex_add_to_revert.labels,
+                before_props=vertex_add_to_revert.after_props,
+            )
+            for vertex_add_to_revert in patch_plan.added_vertices
+        ]
+        if not vertices_to_delete:
+            return
+        all_deleted_ids: set[str] = set()
+        try:
+            async for deleted_ids in self.vertex_deleter.execute(vertices_to_delete=vertices_to_delete):
+                all_deleted_ids |= deleted_ids
+        finally:
+            if all_deleted_ids:
+                patch_plan.drop_added_db_ids(db_ids_to_drop=all_deleted_ids)
+                self.plan_writer.write_added_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+                )
+
+    async def _revert_deleted_vertices(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        vertices_to_add = [
+            VertexToAdd(
+                labels=vertex_delete_to_revert.labels,
+                after_props=vertex_delete_to_revert.before_props,
+                identifier=vertex_delete_to_revert.db_id,
+            )
+            for vertex_delete_to_revert in patch_plan.deleted_vertices
+        ]
+        if not vertices_to_add:
+            return
+
+        deleted_to_undeleted_db_id_map: dict[str, str] = {}
+        try:
+            async for added_db_id_map in self.vertex_adder.execute(vertices_to_add=vertices_to_add):
+                deleted_to_undeleted_db_id_map.update(added_db_id_map)
+        finally:
+            if deleted_to_undeleted_db_id_map:
+                patch_plan.drop_deleted_db_ids(db_ids_to_drop=set(deleted_to_undeleted_db_id_map.keys()))
+                self.plan_writer.write_deleted_db_ids(
+                    patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+                )
+                patch_plan.reverted_deleted_db_id_map.update(deleted_to_undeleted_db_id_map)
+                self.plan_writer.write_reverted_deleted_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.reverted_deleted_db_id_map
+                )
+
+    async def _revert_added_edges(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        edges_to_delete = [
+            EdgeToDelete(
+                db_id=patch_plan.get_database_id_for_added_element(abstract_id=edge_add_to_revert.identifier),
+                from_id=edge_add_to_revert.from_id,
+                to_id=edge_add_to_revert.to_id,
+                edge_type=edge_add_to_revert.edge_type,
+                before_props=edge_add_to_revert.after_props,
+            )
+            for edge_add_to_revert in patch_plan.added_edges
+        ]
+        if not edges_to_delete:
+            return
+        all_deleted_ids: set[str] = set()
+        try:
+            async for deleted_ids in self.edge_deleter.execute(edges_to_delete=edges_to_delete):
+                all_deleted_ids |= deleted_ids
+        finally:
+            if all_deleted_ids:
+                patch_plan.drop_added_db_ids(db_ids_to_drop=all_deleted_ids)
+                self.plan_writer.write_added_db_id_map(
+                    patch_plan_directory=patch_plan_directory, db_id_map=patch_plan.added_element_db_id_map
+                )
+
+    async def _revert_deleted_edges(self, patch_plan: PatchPlan, patch_plan_directory: Path) -> None:
+        edges_to_add = [
+            EdgeToAdd(
+                identifier=edge_delete_to_revert.db_id,
+                from_id=patch_plan.reverted_deleted_db_id_map.get(
+                    edge_delete_to_revert.from_id, edge_delete_to_revert.from_id
+                ),
+                to_id=patch_plan.reverted_deleted_db_id_map.get(
+                    edge_delete_to_revert.to_id, edge_delete_to_revert.to_id
+                ),
+                edge_type=edge_delete_to_revert.edge_type,
+                after_props=edge_delete_to_revert.before_props,
+            )
+            for edge_delete_to_revert in patch_plan.deleted_edges
+        ]
+        if not edges_to_add:
+            return
+
+        undeleted_ids: set[str] = set()
+        try:
+            async for added_db_id_map in self.edge_adder.execute(edges_to_add=edges_to_add):
+                undeleted_ids |= set(added_db_id_map.keys())
+        finally:
+            if undeleted_ids:
+                patch_plan.drop_deleted_db_ids(db_ids_to_drop=undeleted_ids)
+                self.plan_writer.write_deleted_db_ids(
+                    patch_plan_directory=patch_plan_directory, deleted_ids=patch_plan.deleted_db_ids
+                )

infrahub/patch/vertex_adder.py

@@ -0,0 +1,61 @@
+from collections import defaultdict
+from dataclasses import asdict
+from typing import AsyncGenerator
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import VertexToAdd
+
+
+class PatchPlanVertexAdder:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_add_query(self, labels: list[str], vertices_to_add: list[VertexToAdd]) -> dict[str, str]:
+        labels_str = ":".join(labels)
+        serial_vertices_to_add: list[dict[str, str | int | bool]] = [asdict(v) for v in vertices_to_add]
+        query = """
+UNWIND $vertices_to_add AS vertex_to_add
+CREATE (v:%(labels)s)
+SET v = vertex_to_add.after_props
+RETURN vertex_to_add.identifier AS abstract_id, %(id_func_name)s(v) AS db_id
+        """ % {
+            "labels": labels_str,
+            "id_func_name": self.db.get_id_function_name(),
+        }
+        # use transaction to make sure we record the results before committing them
+        try:
+            txn_db = self.db.start_transaction()
+            async with txn_db as txn:
+                results = await txn.execute_query(
+                    query=query, params={"vertices_to_add": serial_vertices_to_add}, type=QueryType.WRITE
+                )
+                abstract_to_concrete_id_map: dict[str, str] = {}
+                for result in results:
+                    abstract_id = result.get("abstract_id")
+                    concrete_id = result.get("db_id")
+                    abstract_to_concrete_id_map[abstract_id] = concrete_id
+        finally:
+            await txn_db.close()
+        return abstract_to_concrete_id_map
+
+    async def execute(self, vertices_to_add: list[VertexToAdd]) -> AsyncGenerator[dict[str, str], None]:
+        """
+        Create vertices_to_add on the database.
+        Returns a generator that yields dictionaries mapping VertexToAdd.identifier to the database-level ID of the newly created vertex.
+        """
+        vertices_map_queue: dict[frozenset[str], list[VertexToAdd]] = defaultdict(list)
+        for vertex_to_add in vertices_to_add:
+            frozen_labels = frozenset(vertex_to_add.labels)
+            vertices_map_queue[frozen_labels].append(vertex_to_add)
+            if len(vertices_map_queue[frozen_labels]) > self.batch_size_limit:
+                yield await self._run_add_query(
+                    labels=list(frozen_labels),
+                    vertices_to_add=vertices_map_queue[frozen_labels],
+                )
+                vertices_map_queue[frozen_labels] = []
+
+        for frozen_labels, vertices_group in vertices_map_queue.items():
+            yield await self._run_add_query(labels=list(frozen_labels), vertices_to_add=vertices_group)

infrahub/patch/vertex_deleter.py

@@ -0,0 +1,33 @@
+from typing import AsyncGenerator
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import VertexToDelete
+
+
+class PatchPlanVertexDeleter:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_delete_query(self, ids_to_delete: list[str]) -> set[str]:
+        query = """
+MATCH (n)
+WHERE %(id_func_name)s(n) IN $ids_to_delete
+DETACH DELETE n
+RETURN %(id_func_name)s(n) AS deleted_id
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        results = await self.db.execute_query(
+            query=query, params={"ids_to_delete": ids_to_delete}, type=QueryType.WRITE
+        )
+        deleted_ids: set[str] = set()
+        for result in results:
+            deleted_id = result.get("deleted_id")
+            deleted_ids.add(deleted_id)
+        return deleted_ids
+
+    async def execute(self, vertices_to_delete: list[VertexToDelete]) -> AsyncGenerator[set[str], None]:
+        for i in range(0, len(vertices_to_delete), self.batch_size_limit):
+            ids_to_delete = [v.db_id for v in vertices_to_delete[i : i + self.batch_size_limit]]
+            yield await self._run_delete_query(ids_to_delete=ids_to_delete)

infrahub/patch/vertex_updater.py

@@ -0,0 +1,28 @@
+from dataclasses import asdict
+
+from infrahub.core.query import QueryType
+from infrahub.database import InfrahubDatabase
+
+from .models import VertexToUpdate
+
+
+class PatchPlanVertexUpdater:
+    def __init__(self, db: InfrahubDatabase, batch_size_limit: int = 1000) -> None:
+        self.db = db
+        self.batch_size_limit = batch_size_limit
+
+    async def _run_update_query(self, vertices_to_update: list[VertexToUpdate]) -> None:
+        query = """
+UNWIND $vertices_to_update AS vertex_to_update
+MATCH (n)
+WHERE %(id_func_name)s(n) = vertex_to_update.db_id
+SET n = vertex_to_update.after_props
+        """ % {"id_func_name": self.db.get_id_function_name()}
+        await self.db.execute_query(
+            query=query, params={"vertices_to_update": [asdict(v) for v in vertices_to_update]}, type=QueryType.WRITE
+        )
+
+    async def execute(self, vertices_to_update: list[VertexToUpdate]) -> None:
+        for i in range(0, len(vertices_to_update), self.batch_size_limit):
+            vertices_slice = vertices_to_update[i : i + self.batch_size_limit]
+            await self._run_update_query(vertices_to_update=vertices_slice)

infrahub/proposed_change/tasks.py

@@ -607,6 +607,7 @@ async def validate_artifacts_generation(model: RequestArtifactDefinitionCheck, s
                 content_type=model.artifact_definition.content_type,
                 transform_type=model.artifact_definition.transform_kind,
                 transform_location=model.artifact_definition.transform_location,
+                convert_query_response=model.artifact_definition.convert_query_response,
                 repository_id=repository.repository_id,
                 repository_name=repository.repository_name,
                 repository_kind=repository.kind,

infrahub/server.py

@@ -23,7 +23,7 @@ from infrahub import __version__, config
 from infrahub.api import router as api
 from infrahub.api.exception_handlers import generic_api_exception_handler
 from infrahub.components import ComponentType
-from infrahub.core.graph.index import node_indexes, rel_indexes
+from infrahub.core.graph.index import attr_value_index, node_indexes, rel_indexes
 from infrahub.core.initialization import initialization
 from infrahub.database import InfrahubDatabase, InfrahubDatabaseMode, get_db
 from infrahub.dependencies.registry import build_component_registry
@@ -58,6 +58,8 @@ async def app_initialization(application: FastAPI, enable_scheduler: bool = True
 
     # Initialize database Driver and load local registry
     database = application.state.db = InfrahubDatabase(mode=InfrahubDatabaseMode.DRIVER, driver=await get_db())
+    if config.SETTINGS.experimental_features.value_db_index:
+        node_indexes.append(attr_value_index)
     database.manager.index.init(nodes=node_indexes, rels=rel_indexes)
 
     build_component_registry()

infrahub/transformations/models.py

@@ -11,6 +11,9 @@ class TransformPythonData(BaseModel):
     branch: str = Field(..., description="The branch to target")
     transform_location: str = Field(..., description="Location of the transform within the repository")
     commit: str = Field(..., description="The commit id to use when generating the artifact")
+    convert_query_response: bool = Field(
+        ..., description="Define if the GraphQL query respose should be converted into InfrahubNode objects"
+    )
     timeout: int = Field(..., description="The timeout value to use when generating the artifact")
 
 

infrahub/transformations/tasks.py

@@ -30,6 +30,7 @@ async def transform_python(message: TransformPythonData, service: InfrahubServic
         location=message.transform_location,
         data=message.data,
         client=service.client,
+        convert_query_response=message.convert_query_response,
     )  # type: ignore[misc]
 
     return transformed_data

infrahub/webhook/models.py

@@ -204,6 +204,7 @@ class TransformWebhook(Webhook):
     transform_class: str = Field(...)
     transform_file: str = Field(...)
     transform_timeout: int = Field(...)
+    convert_query_response: bool = Field(...)
 
     async def _prepare_payload(self, data: dict[str, Any], context: EventContext, service: InfrahubServices) -> None:
         repo: InfrahubReadOnlyRepository | InfrahubRepository
@@ -229,6 +230,7 @@ class TransformWebhook(Webhook):
             branch_name=branch,
             commit=commit,
             location=f"{self.transform_file}::{self.transform_class}",
+            convert_query_response=self.convert_query_response,
             data={"data": data, **context.model_dump()},
             client=service.client,
         )  # type: ignore[misc]
@@ -247,4 +249,5 @@ class TransformWebhook(Webhook):
             transform_class=transform.class_name.value,
             transform_file=transform.file_path.value,
             transform_timeout=transform.timeout.value,
+            convert_query_response=transform.convert_query_response.value or False,
         )

infrahub_sdk/checks.py

@@ -83,7 +83,7 @@ class InfrahubCheck:
     async def init(cls, client: InfrahubClient | None = None, *args: Any, **kwargs: Any) -> InfrahubCheck:
         """Async init method, If an existing InfrahubClient client hasn't been provided, one will be created automatically."""
         warnings.warn(
-            "InfrahubCheck.init has been deprecated and will be removed in the version in Infrahub SDK 2.0.0",
+            "InfrahubCheck.init has been deprecated and will be removed in version 2.0.0 of the Infrahub Python SDK",
             DeprecationWarning,
             stacklevel=1,
         )

infrahub_sdk/client.py

@@ -847,9 +847,9 @@ class InfrahubClient(BaseClient):
                     self.store.set(node=node)
         return nodes
 
-    def clone(self) -> InfrahubClient:
+    def clone(self, branch: str | None = None) -> InfrahubClient:
         """Return a cloned version of the client using the same configuration"""
-        return InfrahubClient(config=self.config)
+        return InfrahubClient(config=self.config.clone(branch=branch))
 
     async def execute_graphql(
         self,
@@ -1591,9 +1591,9 @@ class InfrahubClientSync(BaseClient):
         node = InfrahubNodeSync(client=self, schema=schema, branch=branch, data={"id": id})
         node.delete()
 
-    def clone(self) -> InfrahubClientSync:
+    def clone(self, branch: str | None = None) -> InfrahubClientSync:
         """Return a cloned version of the client using the same configuration"""
-        return InfrahubClientSync(config=self.config)
+        return InfrahubClientSync(config=self.config.clone(branch=branch))
 
     def execute_graphql(
         self,

infrahub_sdk/config.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from copy import deepcopy
 from typing import Any
 
 from pydantic import Field, field_validator, model_validator
@@ -158,3 +159,19 @@ class Config(ConfigBase):
         elif values.get("recorder") == RecorderType.JSON and "custom_recorder" not in values:
             values["custom_recorder"] = JSONRecorder()
         return values
+
+    def clone(self, branch: str | None = None) -> Config:
+        config: dict[str, Any] = {
+            "default_branch": branch or self.default_branch,
+            "recorder": self.recorder,
+            "custom_recorder": self.custom_recorder,
+            "requester": self.requester,
+            "sync_requester": self.sync_requester,
+            "log": self.log,
+        }
+        covered_keys = list(config.keys())
+        for field in Config.model_fields.keys():
+            if field not in covered_keys:
+                config[field] = deepcopy(getattr(self, field))
+
+        return Config(**config)

infrahub_sdk/ctl/cli_commands.py

@@ -20,7 +20,6 @@ from rich.table import Table
 
 from .. import __version__ as sdk_version
 from ..async_typer import AsyncTyper
-from ..code_generator import CodeGenerator
 from ..ctl import config
 from ..ctl.branch import app as branch_app
 from ..ctl.check import run as run_check
@@ -42,6 +41,8 @@ from ..ctl.utils import (
 )
 from ..ctl.validate import app as validate_app
 from ..exceptions import GraphQLError, ModuleImportError
+from ..node import InfrahubNode
+from ..protocols_generator.generator import CodeGenerator
 from ..schema import MainSchemaTypesAll, SchemaRoot
 from ..template import Jinja2Template
 from ..template.exceptions import JinjaTemplateError
@@ -61,7 +62,7 @@ app.add_typer(schema_app, name="schema")
 app.add_typer(validate_app, name="validate")
 app.add_typer(repository_app, name="repository")
 app.add_typer(menu_app, name="menu")
-app.add_typer(object_app, name="object", hidden=True)
+app.add_typer(object_app, name="object")
 
 app.command(name="dump")(dump)
 app.command(name="load")(load)
@@ -330,7 +331,12 @@ def transform(
         console.print(f"[red]{exc.message}")
         raise typer.Exit(1) from exc
 
-    transform = transform_class(client=client, branch=branch)
+    transform = transform_class(
+        client=client,
+        branch=branch,
+        infrahub_node=InfrahubNode,
+        convert_query_response=transform_config.convert_query_response,
+    )
     # Get data
     query_str = repository_config.get_query(name=transform.query).load_query()
     data = asyncio.run(

infrahub_sdk/ctl/generator.py

@@ -62,7 +62,7 @@ async def run(
         generator = generator_class(
             query=generator_config.query,
             client=client,
-            branch=branch,
+            branch=branch or "",
             params=variables_dict,
             convert_query_response=generator_config.convert_query_response,
             infrahub_node=InfrahubNode,
@@ -91,7 +91,7 @@ async def run(
             generator = generator_class(
                 query=generator_config.query,
                 client=client,
-                branch=branch,
+                branch=branch or "",
                 params=params,
                 convert_query_response=generator_config.convert_query_response,
                 infrahub_node=InfrahubNode,

infrahub_sdk/ctl/menu.py

@@ -7,9 +7,14 @@ from rich.console import Console
 from ..async_typer import AsyncTyper
 from ..ctl.client import initialize_client
 from ..ctl.utils import catch_exception, init_logging
+from ..exceptions import ObjectValidationError, ValidationError
 from ..spec.menu import MenuFile
 from .parameters import CONFIG_PARAM
-from .utils import load_yamlfile_from_disk_and_exit
+from .utils import (
+    display_object_validate_format_error,
+    display_object_validate_format_success,
+    load_yamlfile_from_disk_and_exit,
+)
 
 app = AsyncTyper()
 console = Console()
@@ -39,16 +44,54 @@ async def load(
     files = load_yamlfile_from_disk_and_exit(paths=menus, file_type=MenuFile, console=console)
     client = initialize_client()
 
+    has_errors = False
+
+    for file in files:
+        try:
+            await file.validate_format(client=client, branch=branch)
+        except ValidationError as exc:
+            has_errors = True
+            display_object_validate_format_error(file=file, error=exc, console=console)
+
+    if has_errors:
+        raise typer.Exit(1)
+
     for file in files:
-        file.validate_content()
-        schema = await client.schema.get(kind=file.spec.kind, branch=branch)
-
-        for idx, item in enumerate(file.spec.data):
-            await file.spec.create_node(
-                client=client,
-                schema=schema,
-                data=item,
-                branch=branch,
-                default_schema_kind=file.spec.kind,
-                context={"list_index": idx},
-            )
+        try:
+            await file.process(client=client, branch=branch)
+        except ObjectValidationError as exc:
+            has_errors = True
+            console.print(f"[red] {exc!s}")
+
+    if has_errors:
+        raise typer.Exit(1)
+
+
+@app.command()
+@catch_exception(console=console)
+async def validate(
+    paths: list[Path],
+    debug: bool = False,
+    branch: str = typer.Option(None, help="Branch on which to validate the objects."),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Validate one or multiple menu files."""
+
+    init_logging(debug=debug)
+
+    logging.getLogger("infrahub_sdk").setLevel(logging.INFO)
+
+    files = load_yamlfile_from_disk_and_exit(paths=paths, file_type=MenuFile, console=console)
+    client = initialize_client()
+
+    has_errors = False
+    for file in files:
+        try:
+            await file.validate_format(client=client, branch=branch)
+            display_object_validate_format_success(file=file, console=console)
+        except ValidationError as exc:
+            has_errors = True
+            display_object_validate_format_error(file=file, error=exc, console=console)
+
+    if has_errors:
+        raise typer.Exit(1)