infrahub-server 1.5.0b0__py3-none-any.whl → 1.5.0b2__py3-none-any.whl

infrahub_sdk/{graphql.py → graphql/renderers.py}

@@ -6,10 +6,35 @@ from typing import Any
 
 from pydantic import BaseModel
 
-VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))
+from .constants import VARIABLE_TYPE_MAPPING
 
 
 def convert_to_graphql_as_string(value: Any, convert_enum: bool = False) -> str:  # noqa: PLR0911
+    """Convert a Python value to its GraphQL string representation.
+
+    This function handles various Python types and converts them to their appropriate
+    GraphQL string format, including proper quoting, formatting, and special handling
+    for different data types.
+
+    Args:
+        value: The value to convert to GraphQL string format. Can be None, str, bool,
+            int, float, Enum, list, BaseModel, or any other type.
+        convert_enum: If True, converts Enum values to their underlying value instead
+            of their name. Defaults to False.
+
+    Returns:
+        str: The GraphQL string representation of the value.
+
+    Examples:
+        >>> convert_to_graphql_as_string("hello")
+        '"hello"'
+        >>> convert_to_graphql_as_string(True)
+        'true'
+        >>> convert_to_graphql_as_string([1, 2, 3])
+        '[1, 2, 3]'
+        >>> convert_to_graphql_as_string(None)
+        'null'
+    """
     if value is None:
         return "null"
     if isinstance(value, str) and value.startswith("$"):
@@ -56,6 +81,34 @@ def render_variables_to_string(data: dict[str, type[str | int | float | bool]])
 
 
 def render_query_block(data: dict, offset: int = 4, indentation: int = 4, convert_enum: bool = False) -> list[str]:
+    """Render a dictionary structure as a GraphQL query block with proper formatting.
+
+    This function recursively processes a dictionary to generate GraphQL query syntax
+    with proper indentation, handling of aliases, filters, and nested structures.
+    Special keys like "@filters" and "@alias" are processed for GraphQL-specific
+    formatting.
+
+    Args:
+        data: Dictionary representing the GraphQL query structure. Can contain
+            nested dictionaries, special keys like "@filters" and "@alias", and
+            various value types.
+        offset: Number of spaces to use for initial indentation. Defaults to 4.
+        indentation: Number of spaces to add for each nesting level. Defaults to 4.
+        convert_enum: If True, converts Enum values to their underlying value.
+            Defaults to False.
+
+    Returns:
+        list[str]: List of formatted lines representing the GraphQL query block.
+
+    Examples:
+        >>> data = {"user": {"name": None, "email": None}}
+        >>> render_query_block(data)
+        ['    user {', '        name', '        email', '    }']
+
+        >>> data = {"user": {"@alias": "u", "@filters": {"id": 123}, "name": None}}
+        >>> render_query_block(data)
+        ['    u: user(id: 123) {', '        name', '    }']
+    """
     FILTERS_KEY = "@filters"
     ALIAS_KEY = "@alias"
     KEYWORDS_TO_SKIP = [FILTERS_KEY, ALIAS_KEY]
@@ -97,6 +150,33 @@ def render_query_block(data: dict, offset: int = 4, indentation: int = 4, conver
 
 
 def render_input_block(data: dict, offset: int = 4, indentation: int = 4, convert_enum: bool = False) -> list[str]:
+    """Render a dictionary structure as a GraphQL input block with proper formatting.
+
+    This function recursively processes a dictionary to generate GraphQL input syntax
+    with proper indentation, handling nested objects, arrays, and various data types.
+    Unlike query blocks, input blocks don't handle special keys like "@filters" or
+    "@alias" and focus on data structure representation.
+
+    Args:
+        data: Dictionary representing the GraphQL input structure. Can contain
+            nested dictionaries, lists, and various value types.
+        offset: Number of spaces to use for initial indentation. Defaults to 4.
+        indentation: Number of spaces to add for each nesting level. Defaults to 4.
+        convert_enum: If True, converts Enum values to their underlying value.
+            Defaults to False.
+
+    Returns:
+        list[str]: List of formatted lines representing the GraphQL input block.
+
+    Examples:
+        >>> data = {"name": "John", "age": 30}
+        >>> render_input_block(data)
+        ['    name: "John"', '    age: 30']
+
+        >>> data = {"user": {"name": "John", "hobbies": ["reading", "coding"]}}
+        >>> render_input_block(data)
+        ['    user: {', '        name: "John"', '        hobbies: [', '            "reading",', '            "coding",', '        ]', '    }']
+    """
     offset_str = " " * offset
     lines = []
     for key, value in data.items():
@@ -130,75 +210,3 @@ def render_input_block(data: dict, offset: int = 4, indentation: int = 4, conver
         else:
             lines.append(f"{offset_str}{key}: {convert_to_graphql_as_string(value=value, convert_enum=convert_enum)}")
     return lines
-
-
-class BaseGraphQLQuery:
-    query_type: str = "not-defined"
-    indentation: int = 4
-
-    def __init__(self, query: dict, variables: dict | None = None, name: str | None = None):
-        self.query = query
-        self.variables = variables
-        self.name = name or ""
-
-    def render_first_line(self) -> str:
-        first_line = self.query_type
-
-        if self.name:
-            first_line += " " + self.name
-
-        if self.variables:
-            first_line += f" ({render_variables_to_string(self.variables)})"
-
-        first_line += " {"
-
-        return first_line
-
-
-class Query(BaseGraphQLQuery):
-    query_type = "query"
-
-    def render(self, convert_enum: bool = False) -> str:
-        lines = [self.render_first_line()]
-        lines.extend(
-            render_query_block(
-                data=self.query, indentation=self.indentation, offset=self.indentation, convert_enum=convert_enum
-            )
-        )
-        lines.append("}")
-
-        return "\n" + "\n".join(lines) + "\n"
-
-
-class Mutation(BaseGraphQLQuery):
-    query_type = "mutation"
-
-    def __init__(self, *args: Any, mutation: str, input_data: dict, **kwargs: Any):
-        self.input_data = input_data
-        self.mutation = mutation
-        super().__init__(*args, **kwargs)
-
-    def render(self, convert_enum: bool = False) -> str:
-        lines = [self.render_first_line()]
-        lines.append(" " * self.indentation + f"{self.mutation}(")
-        lines.extend(
-            render_input_block(
-                data=self.input_data,
-                indentation=self.indentation,
-                offset=self.indentation * 2,
-                convert_enum=convert_enum,
-            )
-        )
-        lines.append(" " * self.indentation + "){")
-        lines.extend(
-            render_query_block(
-                data=self.query,
-                indentation=self.indentation,
-                offset=self.indentation * 2,
-                convert_enum=convert_enum,
-            )
-        )
-        lines.append(" " * self.indentation + "}")
-        lines.append("}")
-
-        return "\n" + "\n".join(lines) + "\n"

infrahub_sdk/graphql/utils.py

@@ -0,0 +1,40 @@
+import ast
+
+
+def get_class_def_index(module: ast.Module) -> int:
+    """Get the index of the first class definition in the module.
+    It's useful to insert other classes before the first class definition."""
+    for idx, item in enumerate(module.body):
+        if isinstance(item, ast.ClassDef):
+            return idx
+    return -1
+
+
+def insert_fragments_inline(module: ast.Module, fragment: ast.Module) -> ast.Module:
+    """Insert the Pydantic classes for the fragments inline into the module.
+
+    If no class definitions exist in module, fragments are appended to the end.
+    """
+    module_class_def_index = get_class_def_index(module)
+
+    fragment_classes: list[ast.ClassDef] = [item for item in fragment.body if isinstance(item, ast.ClassDef)]
+
+    # Handle edge case when no class definitions exist
+    if module_class_def_index == -1:
+        # Append fragments to the end of the module
+        module.body.extend(fragment_classes)
+    else:
+        # Insert fragments before the first class definition
+        for idx, item in enumerate(fragment_classes):
+            module.body.insert(module_class_def_index + idx, item)
+
+    return module
+
+
+def remove_fragment_import(module: ast.Module) -> ast.Module:
+    """Remove the fragment import from the module."""
+    for item in module.body:
+        if isinstance(item, ast.ImportFrom) and item.module == "fragments":
+            module.body.remove(item)
+            return module
+    return module

infrahub_sdk/protocols.py

@@ -131,6 +131,7 @@ class CoreGenericRepository(CoreNode):
     queries: RelationshipManager
     checks: RelationshipManager
     generators: RelationshipManager
+    groups_objects: RelationshipManager
 
 
 class CoreGroup(CoreNode):
@@ -355,6 +356,10 @@ class CoreGeneratorAction(CoreAction):
     generator: RelatedNode
 
 
+class CoreGeneratorAwareGroup(CoreGroup):
+    pass
+
+
 class CoreGeneratorCheck(CoreCheck):
     instance: String
 
@@ -366,6 +371,8 @@ class CoreGeneratorDefinition(CoreTaskTarget):
     file_path: String
     class_name: String
     convert_query_response: BooleanOptional
+    execute_in_proposed_change: BooleanOptional
+    execute_after_merge: BooleanOptional
     query: RelatedNode
     repository: RelatedNode
     targets: RelatedNode
@@ -681,6 +688,7 @@ class CoreGenericRepositorySync(CoreNodeSync):
     queries: RelationshipManagerSync
     checks: RelationshipManagerSync
     generators: RelationshipManagerSync
+    groups_objects: RelationshipManagerSync
 
 
 class CoreGroupSync(CoreNodeSync):
@@ -905,6 +913,10 @@ class CoreGeneratorActionSync(CoreActionSync):
     generator: RelatedNodeSync
 
 
+class CoreGeneratorAwareGroupSync(CoreGroupSync):
+    pass
+
+
 class CoreGeneratorCheckSync(CoreCheckSync):
     instance: String
 
@@ -916,6 +928,8 @@ class CoreGeneratorDefinitionSync(CoreTaskTargetSync):
     file_path: String
     class_name: String
     convert_query_response: BooleanOptional
+    execute_in_proposed_change: BooleanOptional
+    execute_after_merge: BooleanOptional
     query: RelatedNodeSync
     repository: RelatedNodeSync
     targets: RelatedNodeSync

infrahub_sdk/schema/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import inspect
 import json
 import warnings
 from collections.abc import MutableMapping
@@ -90,6 +91,26 @@ MainSchemaTypesAll: TypeAlias = Union[
 ]
 
 
+class SchemaWarningType(Enum):
+    DEPRECATION = "deprecation"
+
+
+class SchemaWarningKind(BaseModel):
+    kind: str = Field(..., description="The kind impacted by the warning")
+    field: str | None = Field(default=None, description="The attribute or relationship impacted by the warning")
+
+    @property
+    def display(self) -> str:
+        suffix = f".{self.field}" if self.field else ""
+        return f"{self.kind}{suffix}"
+
+
+class SchemaWarning(BaseModel):
+    type: SchemaWarningType = Field(..., description="The type of warning")
+    kinds: list[SchemaWarningKind] = Field(default_factory=list, description="The kinds impacted by the warning")
+    message: str = Field(..., description="The message that describes the warning")
+
+
 class InfrahubSchemaBase:
     client: InfrahubClient | InfrahubClientSync
     cache: dict[str, BranchSchema]
@@ -169,7 +190,9 @@ class InfrahubSchemaBase:
     def _validate_load_schema_response(response: httpx.Response) -> SchemaLoadResponse:
         if response.status_code == httpx.codes.OK:
             status = response.json()
-            return SchemaLoadResponse(hash=status["hash"], previous_hash=status["previous_hash"])
+            return SchemaLoadResponse(
+                hash=status["hash"], previous_hash=status["previous_hash"], warnings=status.get("warnings") or []
+            )
 
         if response.status_code in [
             httpx.codes.BAD_REQUEST,
@@ -185,12 +208,16 @@ class InfrahubSchemaBase:
 
     @staticmethod
     def _get_schema_name(schema: type[SchemaType | SchemaTypeSync] | str) -> str:
-        if hasattr(schema, "_is_runtime_protocol") and schema._is_runtime_protocol:  # type: ignore[union-attr]
-            return schema.__name__  # type: ignore[union-attr]
-
         if isinstance(schema, str):
             return schema
 
+        if hasattr(schema, "_is_runtime_protocol") and getattr(schema, "_is_runtime_protocol", None):
+            if inspect.iscoroutinefunction(schema.save):
+                return schema.__name__
+            if schema.__name__[-4:] == "Sync":
+                return schema.__name__[:-4]
+            return schema.__name__
+
         raise ValueError("schema must be a protocol or a string")
 
     @staticmethod
@@ -474,6 +501,25 @@ class InfrahubSchema(InfrahubSchemaBase):
 
         return branch_schema.nodes
 
+    async def get_graphql_schema(self, branch: str | None = None) -> str:
+        """Get the GraphQL schema as a string.
+
+        Args:
+            branch: The branch to get the schema for. Defaults to default_branch.
+
+        Returns:
+            The GraphQL schema as a string.
+        """
+        branch = branch or self.client.default_branch
+        url = f"{self.client.address}/schema.graphql?branch={branch}"
+
+        response = await self.client._get(url=url)
+
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch GraphQL schema: HTTP {response.status_code} - {response.text}")
+
+        return response.text
+
     async def _fetch(self, branch: str, namespaces: list[str] | None = None) -> BranchSchema:
         url_parts = [("branch", branch)]
         if namespaces:
@@ -697,6 +743,25 @@ class InfrahubSchemaSync(InfrahubSchemaBase):
 
         return branch_schema.nodes
 
+    def get_graphql_schema(self, branch: str | None = None) -> str:
+        """Get the GraphQL schema as a string.
+
+        Args:
+            branch: The branch to get the schema for. Defaults to default_branch.
+
+        Returns:
+            The GraphQL schema as a string.
+        """
+        branch = branch or self.client.default_branch
+        url = f"{self.client.address}/schema.graphql?branch={branch}"
+
+        response = self.client._get(url=url)
+
+        if response.status_code != 200:
+            raise ValueError(f"Failed to fetch GraphQL schema: HTTP {response.status_code} - {response.text}")
+
+        return response.text
+
     def _fetch(self, branch: str, namespaces: list[str] | None = None) -> BranchSchema:
         url_parts = [("branch", branch)]
         if namespaces:
@@ -764,6 +829,7 @@ class SchemaLoadResponse(BaseModel):
     hash: str = Field(default="", description="The new hash for the entire schema")
     previous_hash: str = Field(default="", description="The previous hash for the entire schema")
     errors: dict = Field(default_factory=dict, description="Errors reported by the server")
+    warnings: list[SchemaWarning] = Field(default_factory=list, description="Warnings reported by the server")
 
     @property
     def schema_updated(self) -> bool:

infrahub_sdk/schema/repository.py

@@ -96,6 +96,14 @@ class InfrahubGeneratorDefinitionConfig(InfrahubRepositoryConfigElement):
         default=False,
         description="Decide if the generator should convert the result of the GraphQL query to SDK InfrahubNode objects.",
     )
+    execute_in_proposed_change: bool = Field(
+        default=True,
+        description="Decide if the generator should execute in a proposed change.",
+    )
+    execute_after_merge: bool = Field(
+        default=True,
+        description="Decide if the generator should execute after a merge.",
+    )
 
     def load_class(self, import_root: str | None = None, relative_path: str | None = None) -> type[InfrahubGenerator]:
         module = import_module(module_path=self.file_path, import_root=import_root, relative_path=relative_path)

infrahub_sdk/spec/models.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+from pydantic import BaseModel
+
+
+class InfrahubObjectParameters(BaseModel):
+    expand_range: bool = False

infrahub_sdk/spec/object.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-import copy
-import re
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
@@ -10,7 +8,8 @@ from pydantic import BaseModel, Field
 from ..exceptions import ObjectValidationError, ValidationError
 from ..schema import GenericSchemaAPI, RelationshipKind, RelationshipSchema
 from ..yaml import InfrahubFile, InfrahubFileKind
-from .range_expansion import MATCH_PATTERN, range_expansion
+from .models import InfrahubObjectParameters
+from .processors.factory import DataProcessorFactory
 
 if TYPE_CHECKING:
     from ..client import InfrahubClient
@@ -167,47 +166,24 @@ async def get_relationship_info(
     return info
 
 
-def expand_data_with_ranges(data: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    """Expand any item in self.data with range pattern in any value. Supports multiple fields, requires equal expansion length."""
-    range_pattern = re.compile(MATCH_PATTERN)
-    expanded = []
-    for item in data:
-        # Find all fields to expand
-        expand_fields = {}
-        for key, value in item.items():
-            if isinstance(value, str) and range_pattern.search(value):
-                try:
-                    expand_fields[key] = range_expansion(value)
-                except Exception:
-                    # If expansion fails, treat as no expansion
-                    expand_fields[key] = [value]
-        if not expand_fields:
-            expanded.append(item)
-            continue
-        # Check all expanded lists have the same length
-        lengths = [len(v) for v in expand_fields.values()]
-        if len(set(lengths)) > 1:
-            raise ValidationError(f"Range expansion mismatch: fields expanded to different lengths: {lengths}")
-        n = lengths[0]
-        # Zip expanded values and produce new items
-        for i in range(n):
-            new_item = copy.deepcopy(item)
-            for key, values in expand_fields.items():
-                new_item[key] = values[i]
-            expanded.append(new_item)
-    return expanded
-
-
 class InfrahubObjectFileData(BaseModel):
     kind: str
+    parameters: InfrahubObjectParameters = Field(default_factory=InfrahubObjectParameters)
     data: list[dict[str, Any]] = Field(default_factory=list)
 
+    async def _get_processed_data(self, data: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Get data processed according to the strategy"""
+
+        return await DataProcessorFactory.process_data(kind=self.kind, parameters=self.parameters, data=data)
+
     async def validate_format(self, client: InfrahubClient, branch: str | None = None) -> list[ObjectValidationError]:
         errors: list[ObjectValidationError] = []
         schema = await client.schema.get(kind=self.kind, branch=branch)
-        expanded_data = expand_data_with_ranges(self.data)
-        self.data = expanded_data
-        for idx, item in enumerate(expanded_data):
+
+        processed_data = await self._get_processed_data(data=self.data)
+        self.data = processed_data
+
+        for idx, item in enumerate(processed_data):
             errors.extend(
                 await self.validate_object(
                     client=client,
@@ -216,14 +192,16 @@ class InfrahubObjectFileData(BaseModel):
                     data=item,
                     branch=branch,
                     default_schema_kind=self.kind,
+                    parameters=self.parameters,
                 )
             )
         return errors
 
     async def process(self, client: InfrahubClient, branch: str | None = None) -> None:
         schema = await client.schema.get(kind=self.kind, branch=branch)
-        expanded_data = expand_data_with_ranges(self.data)
-        for idx, item in enumerate(expanded_data):
+        processed_data = await self._get_processed_data(data=self.data)
+
+        for idx, item in enumerate(processed_data):
             await self.create_node(
                 client=client,
                 schema=schema,
@@ -243,7 +221,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         errors: list[ObjectValidationError] = []
         context = context.copy() if context else {}
 
@@ -292,6 +272,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
 
@@ -307,7 +288,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[ObjectValidationError]:
+        parameters = parameters or InfrahubObjectParameters()
         context = context.copy() if context else {}
         errors: list[ObjectValidationError] = []
 
@@ -335,6 +318,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
             )
             return errors
@@ -348,8 +332,11 @@ class InfrahubObjectFileData(BaseModel):
             rel_info.find_matching_relationship(peer_schema=peer_schema)
             context.update(rel_info.get_context(value="placeholder"))
 
-            expanded_data = expand_data_with_ranges(data=data["data"])
-            for idx, peer_data in enumerate(expanded_data):
+            processed_data = await DataProcessorFactory.process_data(
+                kind=peer_kind, data=data["data"], parameters=parameters
+            )
+
+            for idx, peer_data in enumerate(processed_data):
                 context["list_index"] = idx
                 errors.extend(
                     await cls.validate_object(
@@ -360,6 +347,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -384,6 +372,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                 )
             return errors
@@ -410,7 +399,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> InfrahubNode:
+        parameters = parameters or InfrahubObjectParameters()
         context = context.copy() if context else {}
 
         errors = await cls.validate_object(
@@ -421,6 +412,7 @@ class InfrahubObjectFileData(BaseModel):
             context=context,
             branch=branch,
             default_schema_kind=default_schema_kind,
+            parameters=parameters,
         )
         if errors:
             messages = [str(error) for error in errors]
@@ -466,6 +458,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes[0]
 
@@ -477,6 +470,7 @@ class InfrahubObjectFileData(BaseModel):
                             data=value,
                             branch=branch,
                             default_schema_kind=default_schema_kind,
+                            parameters=parameters,
                         )
                         clean_data[key] = nodes
 
@@ -515,6 +509,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
 
         return node
@@ -530,7 +525,9 @@ class InfrahubObjectFileData(BaseModel):
         context: dict | None = None,
         branch: str | None = None,
         default_schema_kind: str | None = None,
+        parameters: InfrahubObjectParameters | None = None,
     ) -> list[InfrahubNode]:
+        parameters = parameters or InfrahubObjectParameters()
         nodes: list[InfrahubNode] = []
         context = context.copy() if context else {}
 
@@ -550,6 +547,7 @@ class InfrahubObjectFileData(BaseModel):
                 context=context,
                 branch=branch,
                 default_schema_kind=default_schema_kind,
+                parameters=parameters,
             )
             return [new_node]
 
@@ -563,7 +561,10 @@ class InfrahubObjectFileData(BaseModel):
                 rel_info.find_matching_relationship(peer_schema=peer_schema)
                 context.update(rel_info.get_context(value=parent_node.id))
 
-            expanded_data = expand_data_with_ranges(data=data["data"])
+            expanded_data = await DataProcessorFactory.process_data(
+                kind=peer_kind, data=data["data"], parameters=parameters
+            )
+
             for idx, peer_data in enumerate(expanded_data):
                 context["list_index"] = idx
                 if isinstance(peer_data, dict):
@@ -575,6 +576,7 @@ class InfrahubObjectFileData(BaseModel):
                         context=context,
                         branch=branch,
                         default_schema_kind=default_schema_kind,
+                        parameters=parameters,
                     )
                     nodes.append(node)
             return nodes
@@ -600,6 +602,7 @@ class InfrahubObjectFileData(BaseModel):
                     context=context,
                     branch=branch,
                     default_schema_kind=default_schema_kind,
+                    parameters=parameters,
                 )
                 nodes.append(node)
 
@@ -633,14 +636,20 @@ class ObjectFile(InfrahubFile):
     @property
     def spec(self) -> InfrahubObjectFileData:
         if not self._spec:
-            self._spec = InfrahubObjectFileData(**self.data.spec)
+            try:
+                self._spec = InfrahubObjectFileData(**self.data.spec)
+            except Exception as exc:
+                raise ValidationError(identifier=str(self.location), message=str(exc))
         return self._spec
 
     def validate_content(self) -> None:
         super().validate_content()
         if self.kind != InfrahubFileKind.OBJECT:
             raise ValueError("File is not an Infrahub Object file")
-        self._spec = InfrahubObjectFileData(**self.data.spec)
+        try:
+            self._spec = InfrahubObjectFileData(**self.data.spec)
+        except Exception as exc:
+            raise ValidationError(identifier=str(self.location), message=str(exc))
 
     async def validate_format(self, client: InfrahubClient, branch: str | None = None) -> None:
         self.validate_content()