django-cfg 1.4.62__py3-none-any.whl → 1.4.64__py3-none-any.whl

django_cfg/modules/django_client/core/generator/go/files_generator.py

@@ -0,0 +1,133 @@
+"""
+Files Generator - Generates auxiliary files (go.mod, README, Makefile, etc.).
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jinja2 import Environment
+
+    from ...ir import IRContext
+    from ..base import GeneratedFile
+    from .generator import GoGenerator
+
+
+class FilesGenerator:
+    """Generates auxiliary files for Go client."""
+
+    def __init__(
+        self,
+        jinja_env: Environment,
+        context: IRContext,
+        generator: GoGenerator,
+    ):
+        """Initialize files generator."""
+        self.jinja_env = jinja_env
+        self.context = context
+        self.generator = generator
+
+    def generate_go_mod(self) -> GeneratedFile:
+        """Generate go.mod file."""
+        template = self.jinja_env.get_template("go.mod.j2")
+
+        module_name = self.generator.package_config.get("module_name", "apiclient")
+        go_version = self.generator.package_config.get("go_version", "1.21")
+
+        content = template.render(
+            module_name=module_name,
+            go_version=go_version,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="go.mod",
+            content=content,
+            description="Go module definition"
+        )
+
+    def generate_readme(self) -> GeneratedFile:
+        """Generate README.md file."""
+        template = self.jinja_env.get_template("README.md.j2")
+
+        content = template.render(
+            module_name=self.generator.package_config.get("module_name", "apiclient"),
+            api_title=self.context.openapi_info.title if self.context.openapi_info else "API Client",
+            api_version=self.context.openapi_info.api_version if self.context.openapi_info else "1.0.0",
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="README.md",
+            content=content,
+            description="Usage documentation"
+        )
+
+    def generate_makefile(self) -> GeneratedFile:
+        """Generate Makefile."""
+        template = self.jinja_env.get_template("Makefile.j2")
+
+        content = template.render(
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="Makefile",
+            content=content,
+            description="Build automation"
+        )
+
+    def generate_errors_file(self, shared: bool = False) -> GeneratedFile:
+        """
+        Generate errors.go with API error handling.
+
+        Args:
+            shared: If True, generate in shared/ package for namespaced structure
+        """
+        template = self.jinja_env.get_template("errors.go.j2")
+
+        package_name = "shared" if shared else self.generator.package_name
+        path = "shared/errors.go" if shared else "errors.go"
+
+        content = template.render(
+            package_name=package_name,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path=path,
+            content=content,
+            description="API error types"
+        )
+
+    def generate_middleware_file(self) -> GeneratedFile:
+        """Generate middleware.go with retry, logging, rate limiting."""
+        template = self.jinja_env.get_template("middleware.go.j2")
+
+        content = template.render(
+            package_name=self.generator.package_name,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="middleware.go",
+            content=content,
+            description="HTTP middleware (retry, logging, rate limiting)"
+        )
+
+    def generate_validation_file(self) -> GeneratedFile:
+        """Generate validation.go with client-side validation helpers."""
+        template = self.jinja_env.get_template("validation.go.j2")
+
+        content = template.render(
+            package_name=self.generator.package_name,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="validation.go",
+            content=content,
+            description="Client-side validation helpers"
+        )

django_cfg/modules/django_client/core/generator/go/generator.py

@@ -0,0 +1,203 @@
+"""
+Go Generator - Main orchestrator for Go client generation.
+
+Coordinates all sub-generators:
+- ModelsGenerator: Go structs and enums
+- OperationsGenerator: Operation methods
+- ClientGenerator: HTTP client
+- FilesGenerator: Auxiliary files (go.mod, README, Makefile)
+"""
+
+from __future__ import annotations
+
+import pathlib
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+from ...ir import IROperationObject, IRSchemaObject
+from ..base import BaseGenerator, GeneratedFile
+from .client_generator import ClientGenerator
+from .files_generator import FilesGenerator
+from .models_generator import ModelsGenerator
+from .naming import get_go_package_name
+from .operations_generator import OperationsGenerator
+from .type_mapper import GoTypeMapper
+
+
+class GoGenerator(BaseGenerator):
+    """
+    Go client generator.
+
+    Generates:
+    - models.go: Go structs (User, UserRequest, PatchedUser)
+    - enums.go: Enum types with constants
+    - client.go: HTTP client with all operations
+    - errors.go: API error handling
+    - go.mod: Module definition
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Setup Jinja2 environment
+        templates_dir = pathlib.Path(__file__).parent / "templates"
+        self.jinja_env = Environment(
+            loader=FileSystemLoader(str(templates_dir)),
+            autoescape=select_autoescape(['html', 'xml']),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        # Initialize type mapper
+        # Use types package for namespaced structure to avoid import cycles
+        use_types_pkg = self.client_structure == "namespaced"
+        self.type_mapper = GoTypeMapper(use_types_package=use_types_pkg)
+
+        # Get package name
+        self.package_name = get_go_package_name(
+            self.package_config.get("name", "apiclient")
+        )
+
+        # Initialize sub-generators
+        self.models_gen = ModelsGenerator(self.jinja_env, self.context, self)
+        self.operations_gen = OperationsGenerator(self.jinja_env, self.context, self)
+        self.client_gen = ClientGenerator(self.jinja_env, self.context, self, self.operations_gen)
+        self.files_gen = FilesGenerator(self.jinja_env, self.context, self)
+
+    def generate(self) -> list[GeneratedFile]:
+        """Generate all Go client files."""
+        files = []
+
+        if self.client_structure == "namespaced":
+            # Generate per-app folders
+            ops_by_tag = self.group_operations_by_tag()
+
+            for tag, operations in sorted(ops_by_tag.items()):
+                # Generate app folder (models.go, operations.go)
+                app_files = self._generate_app_folder(tag, operations)
+                if app_files:
+                    files.extend(app_files)
+
+            # Generate shared enums.go
+            all_schemas = self.context.schemas
+            all_enums = self._collect_enums_from_schemas(all_schemas)
+            if all_enums:
+                enum_file = self.models_gen.generate_shared_enums_file(all_enums)
+                if enum_file:
+                    files.append(enum_file)
+
+            # Generate main client.go
+            files.append(self.client_gen.generate_main_client_file(ops_by_tag))
+
+            # Generate supporting files in shared/ package to avoid circular imports
+            files.append(self.files_gen.generate_errors_file(shared=True))
+            files.append(self.files_gen.generate_middleware_file())
+            files.append(self.files_gen.generate_validation_file())
+
+            if self.generate_package_files:
+                files.append(self.files_gen.generate_go_mod())
+                files.append(self.files_gen.generate_readme())
+                files.append(self.files_gen.generate_makefile())
+        else:
+            # Flat structure
+            files.append(self.models_gen.generate_models_file())
+
+            enum_schemas = self.get_enum_schemas()
+            if enum_schemas:
+                enum_file = self.models_gen.generate_enums_file()
+                if enum_file:
+                    files.append(enum_file)
+
+            files.append(self.client_gen.generate_client_file())
+            files.append(self.files_gen.generate_errors_file())
+            files.append(self.files_gen.generate_middleware_file())
+            files.append(self.files_gen.generate_validation_file())
+
+            if self.generate_package_files:
+                files.append(self.files_gen.generate_go_mod())
+                files.append(self.files_gen.generate_readme())
+                files.append(self.files_gen.generate_makefile())
+
+        return files
+
+    def _generate_app_folder(self, tag: str, operations: list[IROperationObject]) -> list[GeneratedFile]:
+        """Generate folder for a specific app (tag)."""
+        files = []
+
+        # Get schemas used by this app
+        app_schemas = self._get_schemas_for_operations(operations)
+
+        # Generate models.go for this app
+        models_file = self.models_gen.generate_app_models_file(tag, app_schemas, operations)
+        if models_file:
+            files.append(models_file)
+
+        # Generate client.go with HTTP operations for this app
+        client_file = self.client_gen.generate_subpackage_client_file(tag, operations)
+        if client_file:
+            files.append(client_file)
+
+        return files
+
+    def _get_schemas_for_operations(self, operations: list[IROperationObject]) -> dict[str, IRSchemaObject]:
+        """Get all schemas used by given operations, including nested dependencies."""
+        schemas = {}
+        schemas_to_process = set()
+
+        # Collect top-level schemas from operations
+        for operation in operations:
+            # Request body schemas
+            if operation.request_body and operation.request_body.schema_name:
+                schemas_to_process.add(operation.request_body.schema_name)
+
+            # Patch request body schemas
+            if operation.patch_request_body and operation.patch_request_body.schema_name:
+                schemas_to_process.add(operation.patch_request_body.schema_name)
+
+            # Response schemas
+            for status_code, response in operation.responses.items():
+                if response.schema_name:
+                    schemas_to_process.add(response.schema_name)
+
+        # Recursively collect all dependencies
+        processed = set()
+        while schemas_to_process:
+            schema_name = schemas_to_process.pop()
+            if schema_name in processed or schema_name not in self.context.schemas:
+                continue
+
+            processed.add(schema_name)
+            schema = self.context.schemas[schema_name]
+            schemas[schema_name] = schema
+
+            # Find nested schema references
+            if schema.properties:
+                for prop_name, prop_schema in schema.properties.items():
+                    # Direct reference to another schema
+                    if prop_schema.ref and prop_schema.ref in self.context.schemas:
+                        schemas_to_process.add(prop_schema.ref)
+
+                    # Array items reference
+                    if prop_schema.items and prop_schema.items.ref:
+                        if prop_schema.items.ref in self.context.schemas:
+                            schemas_to_process.add(prop_schema.items.ref)
+
+        return schemas
+
+    def _create_generated_file(self, path: str, content: str, description: str) -> GeneratedFile:
+        """Create GeneratedFile instance."""
+        return GeneratedFile(path=path, content=content, description=description)
+
+    # Backward compatibility - delegate to sub-generators
+    def generate_schema(self, schema: IRSchemaObject) -> str:
+        """Generate Go struct for schema (delegates to ModelsGenerator)."""
+        return self.models_gen.generate_schema(schema)
+
+    def generate_enum(self, schema: IRSchemaObject) -> str:
+        """Generate enum type (not directly supported, returns empty)."""
+        return ""  # Go enums are handled differently
+
+    def generate_operation(self, operation: IROperationObject, remove_tag_prefix: bool = False) -> str:
+        """Generate method for operation (for compatibility)."""
+        op_method = self.operations_gen.generate_operation_method(operation, remove_tag_prefix)
+        return f"func (c *Client) {op_method['name']}(...) (...) {{ ... }}"

django_cfg/modules/django_client/core/generator/go/models_generator.py

@@ -0,0 +1,304 @@
+"""
+Models Generator - Generates Go structs from IR schemas.
+
+Handles generation of:
+- Response models (User, Post, etc.)
+- Request models (UserRequest, PostRequest)
+- Patch models (PatchedUser, PatchedPost)
+- Enum types with constants
+"""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from jinja2 import Environment
+
+    from ...ir import IRContext, IRSchemaObject
+    from ..base import GeneratedFile
+    from .generator import GoGenerator
+
+
+class ModelsGenerator:
+    """Generates Go struct definitions from IR schemas."""
+
+    def __init__(
+        self,
+        jinja_env: Environment,
+        context: IRContext,
+        generator: GoGenerator,
+    ):
+        """
+        Initialize models generator.
+
+        Args:
+            jinja_env: Jinja2 environment
+            context: IRContext from parser
+            generator: Parent GoGenerator instance
+        """
+        self.jinja_env = jinja_env
+        self.context = context
+        self.generator = generator
+
+    def generate_models_file(self) -> GeneratedFile:
+        """
+        Generate models.go with all struct definitions.
+
+        Contains:
+        - All response models (User, Post, etc.)
+        - All request models (UserRequest, PostRequest)
+        - All patch models (PatchedUser, PatchedPost)
+
+        Returns:
+            GeneratedFile with models.go content
+        """
+        template = self.jinja_env.get_template("models.go.j2")
+
+        structs = []
+
+        # Generate response models
+        for schema_name, schema in sorted(self.context.response_models.items()):
+            struct_def = self.generator.type_mapper.ir_schema_to_struct(schema)
+            structs.append(struct_def)
+
+        # Generate request models
+        for schema_name, schema in sorted(self.context.request_models.items()):
+            struct_def = self.generator.type_mapper.ir_schema_to_struct(schema)
+            structs.append(struct_def)
+
+        # Generate patch models
+        for schema_name, schema in sorted(self.context.patch_models.items()):
+            struct_def = self.generator.type_mapper.ir_schema_to_struct(schema)
+            structs.append(struct_def)
+
+        # Collect imports
+        imports = self._collect_imports(structs)
+
+        content = template.render(
+            package_name=self.generator.package_name,
+            structs=structs,
+            imports=imports,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="models.go",
+            content=content,
+            description="API data models"
+        )
+
+    def generate_enums_file(self) -> GeneratedFile:
+        """
+        Generate enums.go with enum type definitions.
+
+        Go approach to enums:
+        ```go
+        type StatusEnum int64
+
+        const (
+            StatusNew StatusEnum = 1
+            StatusInProgress StatusEnum = 2
+            StatusComplete StatusEnum = 3
+        )
+
+        func (s StatusEnum) String() string {
+            switch s {
+            case StatusNew:
+                return "STATUS_NEW"
+            case StatusInProgress:
+                return "STATUS_IN_PROGRESS"
+            case StatusComplete:
+                return "STATUS_COMPLETE"
+            default:
+                return fmt.Sprintf("StatusEnum(%d)", s)
+            }
+        }
+
+        func (s StatusEnum) MarshalJSON() ([]byte, error) {
+            return json.Marshal(int64(s))
+        }
+
+        func (s *StatusEnum) UnmarshalJSON(data []byte) error {
+            var v int64
+            if err := json.Unmarshal(data, &v); err != nil {
+                return err
+            }
+            *s = StatusEnum(v)
+            return nil
+        }
+        ```
+
+        Returns:
+            GeneratedFile with enums.go content
+        """
+        template = self.jinja_env.get_template("enums.go.j2")
+
+        enums = []
+        for schema_name, schema in sorted(self.context.enum_schemas.items()):
+            enum_def = self.generator.type_mapper.generate_enum_definition(schema)
+            enums.append(enum_def)
+
+        if not enums:
+            # No enums to generate
+            return None
+
+        content = template.render(
+            package_name=self.generator.package_name,
+            enums=enums,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="enums.go",
+            content=content,
+            description="API enum types"
+        )
+
+    def generate_shared_enums_file(self, enums: dict[str, IRSchemaObject]) -> GeneratedFile:
+        """
+        Generate shared enums.go (for namespaced structure).
+
+        Args:
+            enums: Dictionary of enum schemas
+
+        Returns:
+            GeneratedFile with shared enums.go content
+        """
+        template = self.jinja_env.get_template("enums.go.j2")
+
+        enum_defs = []
+        for schema_name, schema in sorted(enums.items()):
+            enum_def = self.generator.type_mapper.generate_enum_definition(schema)
+            enum_defs.append(enum_def)
+
+        if not enum_defs:
+            return None
+
+        content = template.render(
+            package_name="types",
+            enums=enum_defs,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path="types/enums.go",
+            content=content,
+            description="Shared API enum types"
+        )
+
+    def generate_app_models_file(
+        self,
+        tag: str,
+        schemas: dict[str, IRSchemaObject],
+        operations: list,
+    ) -> GeneratedFile:
+        """
+        Generate models.go for specific app/tag (namespaced structure).
+
+        Args:
+            tag: Tag name
+            schemas: Schemas used by this app
+            operations: Operations for this app
+
+        Returns:
+            GeneratedFile with app-specific models.go
+        """
+        template = self.jinja_env.get_template("models.go.j2")
+
+        structs = []
+        for schema_name, schema in sorted(schemas.items()):
+            # Skip enum schemas (they go in shared enums.go)
+            if schema.enum:
+                continue
+
+            struct_def = self.generator.type_mapper.ir_schema_to_struct(schema)
+            structs.append(struct_def)
+
+        if not structs:
+            # No models for this app
+            return None
+
+        # Collect imports
+        imports = self._collect_imports(structs)
+
+        # Get folder name for this app
+        folder_name = self.generator.tag_and_app_to_folder_name(tag, operations)
+
+        content = template.render(
+            package_name=folder_name,
+            structs=structs,
+            imports=imports,
+            generated_at=datetime.now().isoformat(),
+        )
+
+        return self.generator._create_generated_file(
+            path=f"{folder_name}/models.go",
+            content=content,
+            description=f"{tag} API models"
+        )
+
+    def _collect_imports(self, structs: list[dict]) -> list[str]:
+        """
+        Collect required imports for structs.
+
+        Args:
+            structs: List of struct definitions
+
+        Returns:
+            List of import paths
+
+        Examples:
+            >>> structs = [{"needs_time_import": True}]
+            >>> imports = generator._collect_imports(structs)
+            >>> "time" in imports
+            True
+        """
+        imports = set()
+
+        # Check if time import is needed
+        for struct in structs:
+            if struct.get("needs_time_import"):
+                imports.add("time")
+
+            # Check if types package is used (for enums)
+            for field in struct.get("fields", []):
+                if "types." in field.get("type", ""):
+                    module_name = self.generator.package_config.get("module_name", "apiclient")
+                    imports.add(f"{module_name}/types")
+                    break
+
+        return sorted(imports)
+
+    def generate_schema(self, schema: IRSchemaObject) -> str:
+        """
+        Generate Go struct code for a single schema (for backward compatibility).
+
+        Args:
+            schema: IRSchemaObject to generate
+
+        Returns:
+            Generated struct code as string
+        """
+        struct_def = self.generator.type_mapper.ir_schema_to_struct(schema)
+
+        lines = []
+
+        # Add doc comment
+        if struct_def["doc"]:
+            lines.append(f"// {struct_def['doc']}")
+
+        # Add struct definition
+        lines.append(f"type {struct_def['name']} struct {{")
+
+        # Add fields
+        for field in struct_def["fields"]:
+            if field["description"]:
+                lines.append(f"\t// {field['description']}")
+
+            lines.append(f"\t{field['name']} {field['type']} {field['json_tag']}")
+
+        lines.append("}")
+
+        return "\n".join(lines)