django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

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)

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

@@ -0,0 +1,193 @@
+"""
+Naming conventions for Go code generation.
+
+Handles conversions between Python/OpenAPI naming and Go naming conventions:
+- snake_case → PascalCase (for exports)
+- snake_case → camelCase (for unexported)
+- Proper Go identifier sanitization
+"""
+
+import re
+
+
+def to_pascal_case(snake_str: str) -> str:
+    """
+    Convert snake_case to PascalCase.
+
+    Args:
+        snake_str: snake_case string
+
+    Returns:
+        PascalCase string
+
+    Examples:
+        >>> to_pascal_case("user_profile")
+        'UserProfile'
+        >>> to_pascal_case("api_key_id")
+        'APIKeyID'
+        >>> to_pascal_case("http_response")
+        'HTTPResponse'
+    """
+    if not snake_str:
+        return ""
+
+    # Handle special acronyms that should be uppercase
+    acronyms = {'id', 'api', 'http', 'https', 'url', 'uri', 'json', 'xml', 'html', 'css', 'sql', 'uuid'}
+
+    # Split by underscore
+    parts = snake_str.split('_')
+
+    # Capitalize each part, with special handling for acronyms
+    result_parts = []
+    for part in parts:
+        if not part:
+            continue
+
+        # If entire part is an acronym, uppercase it
+        if part.lower() in acronyms:
+            result_parts.append(part.upper())
+        else:
+            # Check if part ends with an acronym
+            found_acronym = False
+            for acronym in acronyms:
+                if part.lower().endswith(acronym):
+                    # Split off the acronym
+                    prefix = part[:-len(acronym)]
+                    if prefix:
+                        result_parts.append(prefix.capitalize())
+                    result_parts.append(acronym.upper())
+                    found_acronym = True
+                    break
+
+            if not found_acronym:
+                result_parts.append(part.capitalize())
+
+    return ''.join(result_parts)
+
+
+def to_camel_case(snake_str: str) -> str:
+    """
+    Convert snake_case to camelCase (unexported).
+
+    Args:
+        snake_str: snake_case string
+
+    Returns:
+        camelCase string
+
+    Examples:
+        >>> to_camel_case("user_profile")
+        'userProfile'
+        >>> to_camel_case("http_client")
+        'httpClient'
+    """
+    pascal = to_pascal_case(snake_str)
+    if not pascal:
+        return ""
+
+    # Lowercase the first character
+    return pascal[0].lower() + pascal[1:]
+
+
+def sanitize_go_identifier(name: str) -> str:
+    """
+    Sanitize string to valid Go identifier.
+
+    Args:
+        name: Raw identifier name
+
+    Returns:
+        Valid Go identifier
+
+    Examples:
+        >>> sanitize_go_identifier("user-profile")
+        'UserProfile'
+        >>> sanitize_go_identifier("2users")
+        'N2users'
+        >>> sanitize_go_identifier("class")
+        'Class'
+    """
+    # Replace hyphens with underscores
+    name = name.replace('-', '_')
+
+    # Remove invalid characters
+    name = re.sub(r'[^a-zA-Z0-9_]', '', name)
+
+    # If starts with digit, prefix with 'N'
+    if name and name[0].isdigit():
+        name = f'N{name}'
+
+    # Convert to PascalCase
+    return to_pascal_case(name) if name else 'Unknown'
+
+
+def to_snake_case(camel_str: str) -> str:
+    """
+    Convert PascalCase/camelCase to snake_case.
+
+    Args:
+        camel_str: PascalCase or camelCase string
+
+    Returns:
+        snake_case string
+
+    Examples:
+        >>> to_snake_case("UserProfile")
+        'user_profile'
+        >>> to_snake_case("APIKey")
+        'api_key'
+        >>> to_snake_case("HTTPSConnection")
+        'https_connection'
+    """
+    # Insert underscore before uppercase letters (except first)
+    s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', camel_str)
+    # Insert underscore before uppercase letters followed by lowercase
+    return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
+
+
+def get_go_field_name(field_name: str) -> str:
+    """
+    Get Go struct field name (exported PascalCase).
+
+    Args:
+        field_name: Original field name (snake_case)
+
+    Returns:
+        Go field name (PascalCase)
+
+    Examples:
+        >>> get_go_field_name("user_id")
+        'UserID'
+        >>> get_go_field_name("created_at")
+        'CreatedAt'
+    """
+    return to_pascal_case(field_name)
+
+
+def get_go_package_name(name: str) -> str:
+    """
+    Get valid Go package name (lowercase, no underscores).
+
+    Args:
+        name: Package name
+
+    Returns:
+        Valid Go package name
+
+    Examples:
+        >>> get_go_package_name("api_client")
+        'apiclient'
+        >>> get_go_package_name("UserService")
+        'userservice'
+    """
+    # Convert to lowercase
+    name = name.lower()
+
+    # Remove invalid characters (keep only letters and digits)
+    name = re.sub(r'[^a-z0-9]', '', name)
+
+    # Must not start with digit
+    if name and name[0].isdigit():
+        name = f'pkg{name}'
+
+    return name or 'client'

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

@@ -0,0 +1,134 @@
+"""
+Operations Generator - Generates Go client methods from IR operations.
+
+Handles generation of type-safe client methods for each API operation.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .naming import to_pascal_case
+
+if TYPE_CHECKING:
+    from jinja2 import Environment
+
+    from ...ir import IRContext, IROperationObject
+    from .generator import GoGenerator
+
+
+class OperationsGenerator:
+    """Generates Go client operation methods from IR operations."""
+
+    def __init__(
+        self,
+        jinja_env: Environment,
+        context: IRContext,
+        generator: GoGenerator,
+    ):
+        """
+        Initialize operations 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_operation_method(
+        self,
+        operation: IROperationObject,
+        remove_tag_prefix: bool = False,
+    ) -> dict:
+        """
+        Generate Go method definition for an operation.
+
+        Args:
+            operation: IROperationObject to generate
+            remove_tag_prefix: Remove tag prefix from operation name
+
+        Returns:
+            Dictionary with operation method info
+        """
+        # Get method name
+        op_id = operation.operation_id
+        if remove_tag_prefix and operation.tags:
+            op_id = self.generator.remove_tag_prefix(op_id, operation.tags[0])
+
+        method_name = to_pascal_case(op_id)
+
+        # Get request/response types
+        request_type = None
+        if operation.request_body and operation.request_body.schema_name:
+            request_type = operation.request_body.schema_name
+            # Handle inline request bodies (multipart/form-data, etc.)
+            if request_type == "InlineRequestBody":
+                request_type = "map[string]interface{}"
+
+        response_type = "interface{}"
+        if operation.responses.get("200") and operation.responses["200"].schema_name:
+            response_type = operation.responses["200"].schema_name
+        elif operation.responses.get("201") and operation.responses["201"].schema_name:
+            response_type = operation.responses["201"].schema_name
+
+        # Build parameters
+        params = []
+
+        # Path parameters
+        for param in operation.parameters:
+            if param.location == "path":
+                params.append({
+                    "name": param.name,
+                    "type": self._get_param_go_type(param.schema_type),
+                    "location": "path",
+                })
+
+        # Query parameters struct (if any)
+        query_params = [p for p in operation.parameters if p.location == "query"]
+        query_params_struct = None
+        if query_params:
+            params_struct_name = f"{method_name}Params"
+            params.append({
+                "name": "params",
+                "type": f"*{params_struct_name}",
+                "location": "query",
+            })
+
+            # Build query params struct definition
+            query_params_struct = {
+                "name": params_struct_name,
+                "fields": [
+                    {
+                        "name": to_pascal_case(p.name),
+                        "type": self._get_param_go_type(p.schema_type),
+                        "json_name": p.name,
+                        "required": p.required,
+                    }
+                    for p in query_params
+                ]
+            }
+
+        return {
+            "name": method_name,
+            "http_method": operation.http_method.upper(),
+            "path": operation.path,
+            "parameters": params,
+            "request_type": request_type,
+            "response_type": response_type,
+            "description": operation.summary or operation.description or f"{method_name} operation",
+            "operation_id": operation.operation_id,
+            "query_params_struct": query_params_struct,
+        }
+
+    def _get_param_go_type(self, schema_type: str) -> str:
+        """Get Go type for parameter schema type."""
+        type_map = {
+            "string": "string",
+            "integer": "int64",
+            "number": "float64",
+            "boolean": "bool",
+        }
+        return type_map.get(schema_type, "string")

django_cfg/modules/django_client/core/generator/go/templates/Makefile.j2

@@ -0,0 +1,38 @@
+# Code generated by django-cfg/django_client - DO NOT EDIT.
+# Generated at: {{ generated_at }}
+
+.PHONY: deps build test fmt lint clean all
+
+# Download dependencies
+deps:
+	go mod download
+	go mod tidy
+
+# Build (if there's a cmd/)
+build:
+	@if [ -d "cmd" ]; then \
+		go build -o bin/ ./cmd/...; \
+	else \
+		echo "No cmd/ directory found, skipping build"; \
+	fi
+
+# Run tests
+test:
+	go test -v -race -cover ./...
+
+# Format code
+fmt:
+	go fmt ./...
+	goimports -w .
+
+# Run linter
+lint:
+	golangci-lint run
+
+# Clean build artifacts
+clean:
+	rm -rf bin/
+	go clean
+
+# Run all checks
+all: fmt lint test