feat: defer model build

ariadne_codegen/client_generators/client.py

@@ -1,4 +1,5 @@
 import ast
+from copy import deepcopy
 from typing import Optional, Union, cast
 
 from graphql import OperationDefinitionNode, OperationType
@@ -819,6 +820,10 @@ def get_variable_names(self, arguments: ast.arguments) -> dict[str, str]:
     def _add_import(self, import_: Optional[ast.ImportFrom] = None):
         if not import_:
             return
+        # Shared module-level nodes (UNSET_IMPORT, UPLOAD_IMPORT, ...) must never
+        # reach a generated module: plugins rewrite imports in place, which would
+        # otherwise corrupt the constant for every later run in this process.
+        import_ = deepcopy(import_)
         if self.plugin_manager:
             import_ = self.plugin_manager.generate_client_import(import_)
         if import_.names and import_.module:

ariadne_codegen/client_generators/fragments.py

@@ -22,6 +22,7 @@ def __init__(
         plugin_manager: Optional[PluginManager] = None,
         default_optional_fields_to_none: bool = False,
         include_typename: bool = True,
+        defer_model_build: bool = False,
     ) -> None:
         self.schema = schema
         self.enums_module_name = enums_module_name
@@ -32,6 +33,7 @@ def __init__(
         self.plugin_manager = plugin_manager
         self.default_optional_fields_to_none = default_optional_fields_to_none
         self.include_typename = include_typename
+        self.defer_model_build = defer_model_build
 
         self._fragments_names = set(self.fragments_definitions.keys())
         self._generated_public_names: list[str] = []
@@ -130,6 +132,8 @@ def visit(name):
     def _get_model_rebuild_calls(
         self, top_level_fragments_names: list[str], class_defs: list[ast.ClassDef]
     ) -> list[ast.Call]:
+        if self.defer_model_build:
+            return []
         class_names = [c.name for c in class_defs]
         sorted_fragments_names = sorted(
             top_level_fragments_names, key=class_names.index

ariadne_codegen/client_generators/input_types.py

@@ -1,5 +1,6 @@
 import ast
 from collections import defaultdict
+from copy import deepcopy
 from typing import Optional, cast
 
 from graphql import (
@@ -54,18 +55,20 @@ def __init__(
         convert_to_snake_case: bool = True,
         custom_scalars: Optional[dict[str, ScalarData]] = None,
         plugin_manager: Optional[PluginManager] = None,
+        defer_model_build: bool = False,
     ) -> None:
         self.schema = schema
         self.convert_to_snake_case = convert_to_snake_case
         self.enums_module = enums_module
         self.custom_scalars = custom_scalars if custom_scalars else {}
         self.plugin_manager = plugin_manager
+        self.defer_model_build = defer_model_build
 
         self._imports = [
             generate_import_from([OPTIONAL, ANY, UNION, ANNOTATED], TYPING_MODULE),
             generate_import_from([FIELD_CLASS, PLAIN_SERIALIZER], PYDANTIC_MODULE),
-            base_model_import,
-            *([] if upload_import is None else [upload_import]),
+            deepcopy(base_model_import),
+            *([] if upload_import is None else [deepcopy(upload_import)]),
         ]
         self._dependencies: dict[str, list[str]] = defaultdict(list)
         self._used_enums: dict[str, list[str]] = defaultdict(list)
@@ -88,11 +91,17 @@ def generate(self, types_to_include: Optional[list[str]] = None) -> ast.Module:
             scalar_data = self.custom_scalars[scalar_name]
             self._imports.extend(generate_scalar_imports(scalar_data))
 
-        model_rebuild_calls = [
-            generate_expr(generate_method_call(class_def.name, MODEL_REBUILD_METHOD))
-            for class_def in class_defs
-            if model_has_forward_refs(class_def)
-        ]
+        model_rebuild_calls = (
+            []
+            if self.defer_model_build
+            else [
+                generate_expr(
+                    generate_method_call(class_def.name, MODEL_REBUILD_METHOD)
+                )
+                for class_def in class_defs
+                if model_has_forward_refs(class_def)
+            ]
+        )
 
         module_body = (
             cast(list[ast.stmt], self._imports)