executor abstraction, graphene to strawberry

modelgen/generator/__init__.py

@@ -7,17 +7,17 @@ Supported generators:
 - TypeScriptGenerator: TypeScript interfaces
 - ProtobufGenerator: Protocol Buffer definitions
 - PrismaGenerator: Prisma schema
-- GrapheneGenerator: Graphene ObjectType/InputObjectType classes
+- StrawberryGenerator: Strawberry type/input/enum classes
 """
 
 from typing import Dict, Type
 
 from .base import BaseGenerator
 from .django import DjangoGenerator
-from .graphene import GrapheneGenerator
 from .prisma import PrismaGenerator
 from .protobuf import ProtobufGenerator
 from .pydantic import PydanticGenerator
+from .strawberry import StrawberryGenerator
 from .typescript import TypeScriptGenerator
 
 # Registry of available generators
@@ -29,14 +29,14 @@ GENERATORS: Dict[str, Type[BaseGenerator]] = {
     "protobuf": ProtobufGenerator,
     "proto": ProtobufGenerator,  # Alias
     "prisma": PrismaGenerator,
-    "graphene": GrapheneGenerator,
+    "strawberry": StrawberryGenerator,
 }
 
 __all__ = [
     "BaseGenerator",
     "PydanticGenerator",
     "DjangoGenerator",
-    "GrapheneGenerator",
+    "StrawberryGenerator",
     "TypeScriptGenerator",
     "ProtobufGenerator",
     "PrismaGenerator",

modelgen/generator/strawberry.py

@@ -1,28 +1,29 @@
 """
-Graphene Generator
+Strawberry Generator
 
-Generates graphene ObjectType and InputObjectType classes from model definitions.
+Generates strawberry type, input, and enum classes from model definitions.
 Only generates type definitions — queries, mutations, and resolvers are hand-written.
 """
 
+import dataclasses as dc
 from enum import Enum
 from pathlib import Path
 from typing import Any, List, get_type_hints
 
 from ..helpers import get_origin_name, get_type_name, unwrap_optional
 from ..loader.schema import EnumDefinition, FieldDefinition, ModelDefinition
-from ..types import GRAPHENE_RESOLVERS
+from ..types import STRAWBERRY_RESOLVERS
 from .base import BaseGenerator
 
 
-class GrapheneGenerator(BaseGenerator):
-    """Generates graphene type definition files."""
+class StrawberryGenerator(BaseGenerator):
+    """Generates strawberry type definition files."""
 
     def file_extension(self) -> str:
         return ".py"
 
     def generate(self, models, output_path: Path) -> None:
-        """Generate graphene types to output_path."""
+        """Generate strawberry types to output_path."""
         output_path.parent.mkdir(parents=True, exist_ok=True)
 
         if hasattr(models, "models"):
@@ -47,22 +48,18 @@ class GrapheneGenerator(BaseGenerator):
         enums: List[EnumDefinition],
         api_models: List[ModelDefinition],
     ) -> str:
-        """Generate from ModelDefinition objects."""
         lines = self._generate_header()
 
-        # Generate enums as graphene.Enum
         for enum_def in enums:
             lines.extend(self._generate_enum(enum_def))
             lines.append("")
             lines.append("")
 
-        # Generate domain models as ObjectType
         for model_def in models:
             lines.extend(self._generate_object_type(model_def))
             lines.append("")
             lines.append("")
 
-        # Generate API models — request types as InputObjectType, others as ObjectType
         for model_def in api_models:
             if model_def.name.endswith("Request"):
                 lines.extend(self._generate_input_type(model_def))
@@ -74,7 +71,6 @@ class GrapheneGenerator(BaseGenerator):
         return "\n".join(lines).rstrip() + "\n"
 
     def _generate_from_dataclasses(self, dataclasses: List[type]) -> str:
-        """Generate from Python dataclasses."""
         lines = self._generate_header()
 
         enums_generated = set()
@@ -99,37 +95,38 @@ class GrapheneGenerator(BaseGenerator):
     def _generate_header(self) -> List[str]:
         return [
             '"""',
-            "Graphene Types - GENERATED FILE",
+            "Strawberry Types - GENERATED FILE",
             "",
             "Do not edit directly. Regenerate using modelgen.",
             '"""',
             "",
-            "import graphene",
+            "import strawberry",
+            "from enum import Enum",
+            "from typing import List, Optional",
+            "from uuid import UUID",
+            "from datetime import datetime",
+            "from strawberry.scalars import JSON",
             "",
             "",
         ]
 
     def _generate_enum(self, enum_def: EnumDefinition) -> List[str]:
-        """Generate graphene.Enum from EnumDefinition."""
-        lines = [f"class {enum_def.name}(graphene.Enum):"]
+        lines = ["@strawberry.enum", f"class {enum_def.name}(Enum):"]
         for name, value in enum_def.values:
             lines.append(f'    {name} = "{value}"')
         return lines
 
     def _generate_enum_from_python(self, enum_cls: type) -> List[str]:
-        """Generate graphene.Enum from Python Enum."""
-        lines = [f"class {enum_cls.__name__}(graphene.Enum):"]
+        lines = ["@strawberry.enum", f"class {enum_cls.__name__}(Enum):"]
         for member in enum_cls:
             lines.append(f'    {member.name} = "{member.value}"')
         return lines
 
     def _generate_object_type(self, model_def: ModelDefinition) -> List[str]:
-        """Generate graphene.ObjectType from ModelDefinition."""
         name = model_def.name
-        # Append Type suffix if not already present
         type_name = f"{name}Type" if not name.endswith("Type") else name
 
-        lines = [f"class {type_name}(graphene.ObjectType):"]
+        lines = ["@strawberry.type", f"class {type_name}:"]
         if model_def.docstring:
             doc = model_def.docstring.strip().split("\n")[0]
             lines.append(f'    """{doc}"""')
@@ -139,23 +136,19 @@ class GrapheneGenerator(BaseGenerator):
             lines.append("    pass")
         else:
             for field in model_def.fields:
-                graphene_type = self._resolve_type(field.type_hint, field.optional)
-                lines.append(f"    {field.name} = {graphene_type}")
+                type_str = self._resolve_type(field.type_hint, optional=True)
+                lines.append(f"    {field.name}: {type_str} = None")
 
         return lines
 
     def _generate_input_type(self, model_def: ModelDefinition) -> List[str]:
-        """Generate graphene.InputObjectType from ModelDefinition."""
-        import dataclasses as dc
-
         name = model_def.name
-        # Convert FooRequest -> FooInput
         if name.endswith("Request"):
             input_name = name[: -len("Request")] + "Input"
         else:
             input_name = f"{name}Input"
 
-        lines = [f"class {input_name}(graphene.InputObjectType):"]
+        lines = ["@strawberry.input", f"class {input_name}:"]
         if model_def.docstring:
             doc = model_def.docstring.strip().split("\n")[0]
             lines.append(f'    """{doc}"""')
@@ -164,73 +157,64 @@ class GrapheneGenerator(BaseGenerator):
         if not model_def.fields:
             lines.append("    pass")
         else:
+            # Required fields first, then optional/defaulted
+            required = []
+            optional = []
             for field in model_def.fields:
-                graphene_type = self._resolve_type(field.type_hint, field.optional)
-                # Required only if not optional AND no default value
                 has_default = field.default is not dc.MISSING
                 if not field.optional and not has_default:
-                    graphene_type = self._make_required(graphene_type)
-                elif has_default and not field.optional:
-                    graphene_type = self._add_default(graphene_type, field.default)
-                lines.append(f"    {field.name} = {graphene_type}")
+                    required.append(field)
+                else:
+                    optional.append(field)
+
+            for field in required:
+                type_str = self._resolve_type(field.type_hint, optional=False)
+                lines.append(f"    {field.name}: {type_str}")
+
+            for field in optional:
+                has_default = field.default is not dc.MISSING
+                if has_default and not callable(field.default):
+                    type_str = self._resolve_type(field.type_hint, optional=False)
+                    lines.append(f"    {field.name}: {type_str} = {field.default!r}")
+                else:
+                    type_str = self._resolve_type(field.type_hint, optional=True)
+                    lines.append(f"    {field.name}: {type_str} = None")
 
         return lines
 
     def _generate_object_type_from_dataclass(self, cls: type) -> List[str]:
-        """Generate graphene.ObjectType from a dataclass."""
-        import dataclasses as dc
-
         type_name = f"{cls.__name__}Type"
-        lines = [f"class {type_name}(graphene.ObjectType):"]
+        lines = ["@strawberry.type", f"class {type_name}:"]
 
         hints = get_type_hints(cls)
         for name, type_hint in hints.items():
             if name.startswith("_"):
                 continue
-            graphene_type = self._resolve_type(type_hint, False)
-            lines.append(f"    {name} = {graphene_type}")
+            type_str = self._resolve_type(type_hint, optional=True)
+            lines.append(f"    {name}: {type_str} = None")
 
         return lines
 
     def _resolve_type(self, type_hint: Any, optional: bool) -> str:
-        """Resolve Python type to graphene field call string."""
+        """Resolve Python type hint to a strawberry annotation string."""
         base, is_optional = unwrap_optional(type_hint)
         optional = optional or is_optional
         origin = get_origin_name(base)
         type_name = get_type_name(base)
 
-        # Look up resolver
         resolver = (
-            GRAPHENE_RESOLVERS.get(origin)
-            or GRAPHENE_RESOLVERS.get(type_name)
-            or GRAPHENE_RESOLVERS.get(base)
+            STRAWBERRY_RESOLVERS.get(origin)
+            or STRAWBERRY_RESOLVERS.get(type_name)
+            or STRAWBERRY_RESOLVERS.get(base)
             or (
-                GRAPHENE_RESOLVERS["enum"]
+                STRAWBERRY_RESOLVERS["enum"]
                 if isinstance(base, type) and issubclass(base, Enum)
                 else None
             )
         )
 
-        result = resolver(base) if resolver else "graphene.String"
+        inner = resolver(base) if resolver else "str"
 
-        # List types already have () syntax from resolver
-        if result.startswith("graphene.List("):
-            return result
-
-        # Scalar types: add () call
-        return f"{result}()"
-
-    def _make_required(self, field_str: str) -> str:
-        """Add required=True to a graphene field."""
-        if field_str.endswith("()"):
-            return field_str[:-1] + "required=True)"
-        return field_str
-
-    def _add_default(self, field_str: str, default: Any) -> str:
-        """Add default_value to a graphene field."""
-        if callable(default):
-            # default_factory — skip, graphene doesn't support factories
-            return field_str
-        if field_str.endswith("()"):
-            return field_str[:-1] + f"default_value={default!r})"
-        return field_str
+        if optional:
+            return f"Optional[{inner}]"
+        return inner