infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub_sdk/graphql/plugin.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from ariadne_codegen.plugins.base import Plugin
+
+if TYPE_CHECKING:
+    from graphql import ExecutableDefinitionNode
+
+
+class FutureAnnotationPlugin(Plugin):
+    @staticmethod
+    def insert_future_annotation(module: ast.Module) -> ast.Module:
+        # First check if the future annotation is already present
+        for item in module.body:
+            if isinstance(item, ast.ImportFrom) and item.module == "__future__":
+                if any(alias.name == "annotations" for alias in item.names):
+                    return module
+
+        module.body.insert(0, ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0))
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.insert_future_annotation(module)
+
+
+class StandardTypeHintPlugin(Plugin):
+    @classmethod
+    def replace_list_in_subscript(cls, subscript: ast.Subscript) -> ast.Subscript:
+        if isinstance(subscript.value, ast.Name) and subscript.value.id == "List":
+            subscript.value.id = "list"
+        if isinstance(subscript.slice, ast.Subscript):
+            subscript.slice = cls.replace_list_in_subscript(subscript.slice)
+
+        return subscript
+
+    @classmethod
+    def replace_list_annotations(cls, module: ast.Module) -> ast.Module:
+        for item in module.body:
+            if not isinstance(item, ast.ClassDef):
+                continue
+
+            # replace List with list in the annotations when list is used as a type
+            for class_item in item.body:
+                if not isinstance(class_item, ast.AnnAssign):
+                    continue
+                if isinstance(class_item.annotation, ast.Subscript):
+                    class_item.annotation = cls.replace_list_in_subscript(class_item.annotation)
+
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        module = FutureAnnotationPlugin.insert_future_annotation(module)
+        return self.replace_list_annotations(module)
+
+
+class PydanticBaseModelPlugin(Plugin):
+    @staticmethod
+    def find_base_model_index(module: ast.Module) -> int:
+        for idx, item in enumerate(module.body):
+            if isinstance(item, ast.ImportFrom) and item.module == "base_model":
+                return idx
+        raise ValueError("BaseModel not found in module")
+
+    @classmethod
+    def replace_base_model_import(cls, module: ast.Module) -> ast.Module:
+        base_model_index = cls.find_base_model_index(module)
+        module.body[base_model_index] = ast.ImportFrom(module="pydantic", names=[ast.alias(name="BaseModel")], level=0)
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.replace_base_model_import(module)

infrahub_sdk/graphql/query.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .renderers import render_input_block, render_query_block, render_variables_to_string
+
+
+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.py → graphql/renderers.py}

@@ -1,14 +1,42 @@
 from __future__ import annotations
 
+import json
 from enum import Enum
 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: str | bool | list | BaseModel | Enum | Any, convert_enum: bool = False) -> str:  # noqa: PLR0911
+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("$"):
         return value
     if isinstance(value, Enum):
@@ -16,7 +44,9 @@ def convert_to_graphql_as_string(value: str | bool | list | BaseModel | Enum | A
             return convert_to_graphql_as_string(value=value.value, convert_enum=True)
         return value.name
     if isinstance(value, str):
-        return f'"{value}"'
+        # Use json.dumps() to properly escape the string according to JSON rules,
+        # which are compatible with GraphQL string escaping
+        return json.dumps(value)
     if isinstance(value, bool):
         return repr(value).lower()
     if isinstance(value, list):
@@ -51,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]
@@ -92,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():
@@ -125,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/node/attribute.py

@@ -76,6 +76,8 @@ class Attribute:
         variables: dict[str, Any] = {}
 
         if self.value is None:
+            if self._schema.optional and self.value_has_been_mutated:
+                data["value"] = None
             return data
 
         if isinstance(self.value, str):

infrahub_sdk/node/node.py

@@ -234,15 +234,10 @@ class InfrahubNodeBase:
 
             rel: RelatedNodeBase | RelationshipManagerBase = getattr(self, item_name)
 
-            # BLOCKED by https://github.com/opsmill/infrahub/issues/330
-            # if (
-            #     item is None
-            #     and item_name in self._relationships
-            #     and self._schema.get_relationship(item_name).cardinality == "one"
-            # ):
-            #     data[item_name] = None
-            #     continue
-            # el
+            if rel_schema.cardinality == RelationshipCardinality.ONE and rel_schema.optional and not rel.initialized:
+                data[item_name] = None
+                continue
+
             if rel is None or not rel.initialized:
                 continue
 
@@ -315,7 +310,16 @@ class InfrahubNodeBase:
                         variables.pop(variable_key)
 
         # TODO: I do not feel _great_ about this
-        if not data_item and data_item != [] and item in data:
+        # -> I don't even know who you are (but this is not great indeed) -- gmazoyer (quoting Thanos)
+        original_data_item = original_data.get(item)
+        original_data_item_is_none = original_data_item is None
+        if isinstance(original_data_item, dict):
+            if "node" in original_data_item:
+                original_data_item_is_none = original_data_item["node"] is None
+            elif "id" not in original_data_item:
+                original_data_item_is_none = True
+
+        if item in data and (data_item in ({}, []) or (data_item is None and original_data_item_is_none)):
             data.pop(item)
 
     def _strip_unmodified(self, data: dict, variables: dict) -> tuple[dict, dict]:
@@ -324,7 +328,9 @@ class InfrahubNodeBase:
             relationship_property = getattr(self, relationship)
             if not relationship_property or relationship not in data:
                 continue
-            if not relationship_property.initialized:
+            if not relationship_property.initialized and (
+                not isinstance(relationship_property, RelatedNodeBase) or not relationship_property.schema.optional
+            ):
                 data.pop(relationship)
             elif isinstance(relationship_property, RelationshipManagerBase) and not relationship_property.has_update:
                 data.pop(relationship)
@@ -573,8 +579,7 @@ class InfrahubNode(InfrahubNodeBase):
         self._validate_artifact_support(ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE)
 
         artifact = await self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        content = await self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
-        return content
+        return await self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
 
     async def delete(self, timeout: int | None = None, request_context: RequestContext | None = None) -> None:
         input_data = {"data": {"id": self.id}}
@@ -742,12 +747,11 @@ class InfrahubNode(InfrahubNodeBase):
                 continue
 
             peer_data: dict[str, Any] = {}
-            if rel_schema and prefetch_relationships:
+            should_fetch_relationship = prefetch_relationships or (include is not None and rel_name in include)
+            if rel_schema and should_fetch_relationship:
                 peer_schema = await self._client.schema.get(kind=rel_schema.peer, branch=self._branch)
                 peer_node = InfrahubNode(client=self._client, schema=peer_schema, branch=self._branch)
                 peer_data = await peer_node.generate_query_data_node(
-                    include=include,
-                    exclude=exclude,
                     property=property,
                 )
 
@@ -886,7 +890,11 @@ class InfrahubNode(InfrahubNodeBase):
         await self._process_mutation_result(mutation_name=mutation_name, response=response, timeout=timeout)
 
     async def _process_relationships(
-        self, node_data: dict[str, Any], branch: str, related_nodes: list[InfrahubNode], timeout: int | None = None
+        self,
+        node_data: dict[str, Any],
+        branch: str,
+        related_nodes: list[InfrahubNode],
+        timeout: int | None = None,
     ) -> None:
         """Processes the Relationships of a InfrahubNode and add Related Nodes to a list.
 
@@ -1199,8 +1207,7 @@ class InfrahubNodeSync(InfrahubNodeBase):
     def artifact_fetch(self, name: str) -> str | dict[str, Any]:
         self._validate_artifact_support(ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE)
         artifact = self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        content = self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
-        return content
+        return self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
 
     def delete(self, timeout: int | None = None, request_context: RequestContext | None = None) -> None:
         input_data = {"data": {"id": self.id}}
@@ -1363,7 +1370,8 @@ class InfrahubNodeSync(InfrahubNodeBase):
                 continue
 
             peer_data: dict[str, Any] = {}
-            if rel_schema and prefetch_relationships:
+            should_fetch_relationship = prefetch_relationships or (include is not None and rel_name in include)
+            if rel_schema and should_fetch_relationship:
                 peer_schema = self._client.schema.get(kind=rel_schema.peer, branch=self._branch)
                 peer_node = InfrahubNodeSync(client=self._client, schema=peer_schema, branch=self._branch)
                 peer_data = peer_node.generate_query_data_node(include=include, exclude=exclude, property=property)

infrahub_sdk/playback.py

@@ -56,5 +56,4 @@ class JSONPlayback(BaseSettings):
         with Path(f"{self.directory}/{filename}.json").open(encoding="utf-8") as fobj:
             data = ujson.load(fobj)
 
-        response = httpx.Response(status_code=data["status_code"], content=data["response_content"], request=request)
-        return response
+        return httpx.Response(status_code=data["status_code"], content=data["response_content"], request=request)