infrahub-server 1.2.5__py3-none-any.whl → 1.2.7__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/tasks/registry.py

@@ -61,5 +61,8 @@ async def refresh_branches(db: InfrahubDatabase) -> None:
                 )
 
         purged_branches = await registry.purge_inactive_branches(db=db, active_branches=branches)
-        for branch_name in purged_branches:
+        purged_branches.update(
+            GraphQLSchemaManager.purge_inactive(active_branches=[branch.name for branch in branches])
+        )
+        for branch_name in sorted(purged_branches):
             log.info(f"Removed branch {branch_name!r} from the registry", branch=branch_name, worker=WORKER_IDENTITY)

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/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,7 @@ from ..ctl.utils import (
 )
 from ..ctl.validate import app as validate_app
 from ..exceptions import GraphQLError, ModuleImportError
+from ..protocols_generator.generator import CodeGenerator
 from ..schema import MainSchemaTypesAll, SchemaRoot
 from ..template import Jinja2Template
 from ..template.exceptions import JinjaTemplateError
@@ -61,7 +61,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)

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)

infrahub_sdk/ctl/object.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.object import ObjectFile
 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,9 +44,54 @@ async def load(
     files = load_yamlfile_from_disk_and_exit(paths=paths, file_type=ObjectFile, 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:
+        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 objects files."""
+
+    init_logging(debug=debug)
+
+    logging.getLogger("infrahub_sdk").setLevel(logging.INFO)
+
+    files = load_yamlfile_from_disk_and_exit(paths=paths, file_type=ObjectFile, console=console)
+    client = initialize_client()
+
+    has_errors = False
     for file in files:
-        file.validate_content()
-        schema = await client.schema.get(kind=file.spec.kind, branch=branch)
+        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)
 
-        for item in file.spec.data:
-            await file.spec.create_node(client=client, schema=schema, data=item, branch=branch)
+    if has_errors:
+        raise typer.Exit(1)

infrahub_sdk/ctl/utils.py

@@ -25,6 +25,7 @@ from ..exceptions import (
     SchemaNotFoundError,
     ServerNotReachableError,
     ServerNotResponsiveError,
+    ValidationError,
 )
 from ..yaml import YamlFile
 from .client import initialize_client_sync
@@ -32,6 +33,7 @@ from .exceptions import QueryNotFoundError
 
 if TYPE_CHECKING:
     from ..schema.repository import InfrahubRepositoryConfig
+    from ..spec.object import ObjectFile
 
 YamlFileVar = TypeVar("YamlFileVar", bound=YamlFile)
 T = TypeVar("T")
@@ -198,4 +200,23 @@ def load_yamlfile_from_disk_and_exit(
     if has_error:
         raise typer.Exit(1)
 
-    return data_files
+    return sorted(data_files, key=lambda x: x.location)
+
+
+def display_object_validate_format_success(file: ObjectFile, console: Console) -> None:
+    if file.multiple_documents:
+        console.print(f"[green] File '{file.location}' [{file.document_position}] is Valid!")
+    else:
+        console.print(f"[green] File '{file.location}' is Valid!")
+
+
+def display_object_validate_format_error(file: ObjectFile, error: ValidationError, console: Console) -> None:
+    if file.multiple_documents:
+        console.print(f"[red] File '{file.location}' [{file.document_position}] is not valid!")
+    else:
+        console.print(f"[red] File '{file.location}' is not valid!")
+    if error.messages:
+        for message in error.messages:
+            console.print(f"[red] {message}")
+    else:
+        console.print(f"[red] {error.message}")

infrahub_sdk/exceptions.py

@@ -113,11 +113,29 @@ class InfrahubTransformNotFoundError(Error):
 
 
 class ValidationError(Error):
-    def __init__(self, identifier: str, message: str):
+    def __init__(self, identifier: str, message: str | None = None, messages: list[str] | None = None):
         self.identifier = identifier
         self.message = message
+        self.messages = messages
+        if not messages and not message:
+            self.message = f"Validation Error for {self.identifier}"
         super().__init__(self.message)
 
+    def __str__(self) -> str:
+        if self.messages:
+            return f"{self.identifier}: {', '.join(self.messages)}"
+        return f"{self.identifier}: {self.message}"
+
+
+class ObjectValidationError(Error):
+    def __init__(self, position: list[int | str], message: str):
+        self.position = position
+        self.message = message
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        return f"{'.'.join(map(str, self.position))}: {self.message}"
+
 
 class AuthenticationError(Error):
     def __init__(self, message: str | None = None):