Add a setting that sets default=None to all optional fields so they can be missing from response and still parse

ariadne_codegen/client_generators/fragments.py

@@ -20,6 +20,7 @@ def __init__(
         convert_to_snake_case: bool = True,
         custom_scalars: Optional[dict[str, ScalarData]] = None,
         plugin_manager: Optional[PluginManager] = None,
+        default_optional_fields_to_none: bool = False,
         include_typename: bool = True,
     ) -> None:
         self.schema = schema
@@ -29,6 +30,7 @@ def __init__(
         self.convert_to_snake_case = convert_to_snake_case
         self.custom_scalars = custom_scalars
         self.plugin_manager = plugin_manager
+        self.default_optional_fields_to_none = default_optional_fields_to_none
         self.include_typename = include_typename
 
         self._fragments_names = set(self.fragments_definitions.keys())
@@ -54,6 +56,7 @@ def generate(self, exclude_names: Optional[set[str]] = None) -> ast.Module:
                 convert_to_snake_case=self.convert_to_snake_case,
                 custom_scalars=self.custom_scalars,
                 plugin_manager=self.plugin_manager,
+                default_optional_fields_to_none=self.default_optional_fields_to_none,
                 include_typename=self.include_typename,
             )
             imports.extend(generator.get_imports())

ariadne_codegen/client_generators/package.py

@@ -84,6 +84,7 @@ def __init__(
         custom_scalars: Optional[dict[str, ScalarData]] = None,
         plugin_manager: Optional[PluginManager] = None,
         enable_custom_operations: bool = False,
+        default_optional_fields_to_none: bool = False,
         include_typename: bool = True,
     ) -> None:
         self.package_path = Path(target_path) / package_name
@@ -134,6 +135,7 @@ def __init__(
         )
         self.custom_scalars = custom_scalars if custom_scalars else {}
         self.plugin_manager = plugin_manager
+        self.default_optional_fields_to_none = default_optional_fields_to_none
         self.include_typename = include_typename
 
         self._result_types_files: dict[str, ast.Module] = {}
@@ -201,6 +203,7 @@ def add_operation(self, definition: OperationDefinitionNode):
             convert_to_snake_case=self.convert_to_snake_case,
             custom_scalars=self.custom_scalars,
             plugin_manager=self.plugin_manager,
+            default_optional_fields_to_none=self.default_optional_fields_to_none,
             include_typename=self.include_typename,
         )
         self._unpacked_fragments = self._unpacked_fragments.union(
@@ -457,6 +460,7 @@ def get_package_generator(
         convert_to_snake_case=settings.convert_to_snake_case,
         custom_scalars=settings.scalars,
         plugin_manager=plugin_manager,
+        default_optional_fields_to_none=settings.default_optional_fields_to_none,
         include_typename=settings.include_typename,
     )
     custom_fields_generator = CustomFieldsGenerator(
@@ -537,5 +541,6 @@ def get_package_generator(
         custom_scalars=settings.scalars,
         plugin_manager=plugin_manager,
         enable_custom_operations=settings.enable_custom_operations,
+        default_optional_fields_to_none=settings.default_optional_fields_to_none,
         include_typename=settings.include_typename,
     )

ariadne_codegen/client_generators/result_types.py

@@ -84,6 +84,7 @@ def __init__(
         convert_to_snake_case: bool = True,
         custom_scalars: Optional[dict[str, ScalarData]] = None,
         plugin_manager: Optional[PluginManager] = None,
+        default_optional_fields_to_none: bool = False,
         include_typename: bool = True,
     ) -> None:
         self.schema = schema
@@ -99,6 +100,7 @@ def __init__(
         self.custom_scalars = custom_scalars if custom_scalars else {}
         self.convert_to_snake_case = convert_to_snake_case
         self.plugin_manager = plugin_manager
+        self.default_optional_fields_to_none = default_optional_fields_to_none
         self.include_typename = include_typename
 
         self._imports: list[ast.ImportFrom] = [
@@ -447,6 +449,14 @@ def _process_field_implementation(
             keywords[DEFAULT_KEYWORD] = generate_constant(
                 field_implementation.value.value
             )
+        elif (
+            self.default_optional_fields_to_none
+            and field_implementation.value is None
+            and isinstance(field_implementation.annotation, ast.Subscript)
+            and isinstance(field_implementation.annotation.value, ast.Name)
+            and field_implementation.annotation.value.id == OPTIONAL
+        ):
+            keywords[DEFAULT_KEYWORD] = generate_constant(None)
 
         if keywords:
             field_implementation.value = generate_pydantic_field(keywords)

ariadne_codegen/settings.py

@@ -70,8 +70,9 @@ class ClientSettings(BaseSettings):
     include_all_enums: bool = True
     async_client: bool = True
     opentelemetry_client: bool = False
-    files_to_include: list[str] = field(default_factory=list)
-    scalars: dict[str, ScalarData] = field(default_factory=dict)
+    files_to_include: List[str] = field(default_factory=list)
+    scalars: Dict[str, ScalarData] = field(default_factory=dict)
+    default_optional_fields_to_none: bool = False
     include_typename: bool = True
 
     def __post_init__(self):

tests/client_generators/result_types_generator/test_default_optional_fields.py

@@ -0,0 +1,138 @@
+import ast
+from typing import cast
+
+from graphql import (
+    OperationDefinitionNode,
+    build_ast_schema,
+    parse,
+)
+
+from ariadne_codegen.client_generators.constants import (
+    ALIAS_KEYWORD,
+    DEFAULT_KEYWORD,
+    FIELD_CLASS,
+    OPTIONAL,
+)
+from ariadne_codegen.client_generators.result_types import ResultTypesGenerator
+
+from ...utils import compare_ast, format_graphql_str, get_class_def
+from .schema import SCHEMA_STR
+
+
+def test_default_optional_fields_true():
+    query_str = format_graphql_str(
+        """
+        query CustomQuery {
+            query1 {
+                ... on CustomType {
+                    field1
+                    field2
+                }
+            }
+        }
+        """
+    )
+    expected_results = [
+        ast.AnnAssign(
+            target=ast.Name(id="field_1"),
+            annotation=ast.Name(id='"CustomQueryQuery1Field1"'),
+            value=ast.Call(
+                func=ast.Name(id=FIELD_CLASS),
+                args=[],
+                keywords=[
+                    ast.keyword(
+                        arg=ALIAS_KEYWORD,
+                        value=ast.Constant(value="field1"),
+                    )
+                ],
+            ),
+            simple=1,
+        ),
+        ast.AnnAssign(
+            target=ast.Name(id="field_2"),
+            annotation=ast.Subscript(
+                value=ast.Name(id=OPTIONAL),
+                slice=ast.Name(id='"CustomQueryQuery1Field2"'),
+            ),
+            value=ast.Call(
+                func=ast.Name(id=FIELD_CLASS),
+                args=[],
+                keywords=[
+                    ast.keyword(arg=ALIAS_KEYWORD, value=ast.Constant(value="field2")),
+                    ast.keyword(arg=DEFAULT_KEYWORD, value=ast.Constant(value=None)),
+                ],
+            ),
+            simple=1,
+        ),
+    ]
+    generator = ResultTypesGenerator(
+        schema=build_ast_schema(parse(SCHEMA_STR)),
+        operation_definition=cast(
+            OperationDefinitionNode, parse(query_str).definitions[0]
+        ),
+        enums_module_name="enums",
+        default_optional_fields_to_none=True,
+    )
+    result = generator.generate()
+    classdef = get_class_def(result, 1)
+    assert compare_ast(classdef.body[0], expected_results[0])
+    assert compare_ast(classdef.body[1], expected_results[1])
+
+
+def test_default_optional_fields_false():
+    query_str = format_graphql_str(
+        """
+        query CustomQuery {
+            query1 {
+                ... on CustomType {
+                    field1
+                    field2
+                }
+            }
+        }
+        """
+    )
+    expected_results = [
+        ast.AnnAssign(
+            target=ast.Name(id="field_1"),
+            annotation=ast.Name(id='"CustomQueryQuery1Field1"'),
+            value=ast.Call(
+                func=ast.Name(id=FIELD_CLASS),
+                args=[],
+                keywords=[
+                    ast.keyword(
+                        arg=ALIAS_KEYWORD,
+                        value=ast.Constant(value="field1"),
+                    )
+                ],
+            ),
+            simple=1,
+        ),
+        ast.AnnAssign(
+            target=ast.Name(id="field_2"),
+            annotation=ast.Subscript(
+                value=ast.Name(id=OPTIONAL),
+                slice=ast.Name(id='"CustomQueryQuery1Field2"'),
+            ),
+            value=ast.Call(
+                func=ast.Name(id=FIELD_CLASS),
+                args=[],
+                keywords=[
+                    ast.keyword(arg=ALIAS_KEYWORD, value=ast.Constant(value="field2"))
+                ],
+            ),
+            simple=1,
+        ),
+    ]
+    generator = ResultTypesGenerator(
+        schema=build_ast_schema(parse(SCHEMA_STR)),
+        operation_definition=cast(
+            OperationDefinitionNode, parse(query_str).definitions[0]
+        ),
+        enums_module_name="enums",
+        default_optional_fields_to_none=False,
+    )
+    result = generator.generate()
+    classdef = get_class_def(result, 1)
+    assert compare_ast(classdef.body[0], expected_results[0])
+    assert compare_ast(classdef.body[1], expected_results[1])