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

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

django_cfg/modules/django_client/core/generator/go/templates/README.md.j2

@@ -0,0 +1,55 @@
+# {{ api_title }} - Go Client
+
+Auto-generated Go client for {{ api_title }} (v{{ api_version }}).
+
+Generated at: {{ generated_at }}
+
+## Installation
+
+```bash
+go get {{ module_name }}
+```
+
+## Usage
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"{{ module_name }}"
+)
+
+func main() {
+	// Create client
+	client := {{ module_name }}.NewClient(
+		"https://api.example.com",
+		{{ module_name }}.WithToken("your-api-token"),
+	)
+
+	// Make requests
+	ctx := context.Background()
+
+	// Example: List users
+	// users, err := client.UsersList(ctx, nil)
+	// if err != nil {
+	//     log.Fatal(err)
+	// }
+	// fmt.Printf("Users: %+v\n", users)
+}
+```
+
+## Features
+
+- ✅ Type-safe Go structs
+- ✅ Context-aware requests
+- ✅ Bearer token authentication
+- ✅ Comprehensive error handling
+- ✅ Auto-generated from OpenAPI spec
+
+## Documentation
+
+See the OpenAPI specification for full API documentation.

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

@@ -0,0 +1,122 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+)
+
+// Client is the HTTP API client.
+type Client struct {
+	BaseURL    string
+	HTTPClient *http.Client
+	Token      string // Bearer token for authentication
+}
+
+// Option is a functional option for configuring the Client.
+type Option func(*Client)
+
+// WithHTTPClient sets a custom HTTP client.
+func WithHTTPClient(client *http.Client) Option {
+	return func(c *Client) {
+		c.HTTPClient = client
+	}
+}
+
+// WithToken sets the authentication token.
+func WithToken(token string) Option {
+	return func(c *Client) {
+		c.Token = token
+	}
+}
+
+// NewClient creates a new API client.
+func NewClient(baseURL string, options ...Option) *Client {
+	client := &Client{
+		BaseURL:    baseURL,
+		HTTPClient: &http.Client{},
+	}
+
+	for _, opt := range options {
+		opt(client)
+	}
+
+	return client
+}
+
+// doRequest performs HTTP request with error handling.
+func (c *Client) doRequest(ctx context.Context, method, path string, body interface{}, response interface{}) error {
+	var reqBody io.Reader
+
+	if body != nil {
+		data, err := json.Marshal(body)
+		if err != nil {
+			return fmt.Errorf("failed to marshal request body: %w", err)
+		}
+		reqBody = bytes.NewReader(data)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, c.BaseURL+path, reqBody)
+	if err != nil {
+		return fmt.Errorf("failed to create request: %w", err)
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	if c.Token != "" {
+		req.Header.Set("Authorization", "Bearer "+c.Token)
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= 400 {
+		var apiErr APIError
+		apiErr.StatusCode = resp.StatusCode
+		if err := json.NewDecoder(resp.Body).Decode(&apiErr); err != nil {
+			apiErr.Message = resp.Status
+		}
+		return &apiErr
+	}
+
+	if response != nil {
+		if err := json.NewDecoder(resp.Body).Decode(response); err != nil {
+			return fmt.Errorf("failed to decode response: %w", err)
+		}
+	}
+
+	return nil
+}
+
+{% for operation in operations %}
+// {{ operation.name }} - {{ operation.description }}
+func (c *Client) {{ operation.name }}(ctx context.Context{% for param in operation.parameters %}, {{ param.name }} {{ param.type }}{% endfor %}{% if operation.request_type %}, req *{{ operation.request_type }}{% endif %}) ({% if operation.response_type != 'interface{}' %}*{{ operation.response_type }}{% else %}interface{}{% endif %}, error) {
+	{% if operation.response_type != 'interface{}' %}var response {{ operation.response_type }}{% endif %}
+
+	path := "{{ operation.path }}"
+	{% if operation.parameters %}
+	// TODO: Build path with parameters and query string
+	{% endif %}
+
+	err := c.doRequest(ctx, "{{ operation.http_method }}", path, {% if operation.request_type %}req{% else %}nil{% endif %}, {% if operation.response_type != 'interface{}' %}&response{% else %}nil{% endif %})
+	if err != nil {
+		return nil, err
+	}
+
+	{% if operation.response_type != 'interface{}' %}
+	return &response, nil
+	{% else %}
+	return nil, nil
+	{% endif %}
+}
+
+{% endfor %}

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

@@ -0,0 +1,49 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+{% for enum in enums %}
+// {{ (enum.doc or enum.name) | replace('\n', '\n// ') }}
+type {{ enum.name }} {{ enum.base_type }}
+
+const (
+{% for value in enum['values'] %}
+	// {{ (value.description or value.name) | replace('\n', '\n\t// ') }}
+	{{ value.name }} {{ enum.name }} = {{ value.value if not enum.is_string_enum else '"%s"' % value.value }}
+{% endfor %}
+)
+
+// String returns string representation of {{ enum.name }}.
+func (e {{ enum.name }}) String() string {
+	switch e {
+{% for value in enum['values'] %}
+	case {{ value.name }}:
+		return "{{ value.name }}"
+{% endfor %}
+	default:
+		return fmt.Sprintf("{{ enum.name }}(%v)", {{ enum.base_type }}(e))
+	}
+}
+
+// MarshalJSON implements json.Marshaler.
+func (e {{ enum.name }}) MarshalJSON() ([]byte, error) {
+	return json.Marshal({{ enum.base_type }}(e))
+}
+
+// UnmarshalJSON implements json.Unmarshaler.
+func (e *{{ enum.name }}) UnmarshalJSON(data []byte) error {
+	var v {{ enum.base_type }}
+	if err := json.Unmarshal(data, &v); err != nil {
+		return err
+	}
+	*e = {{ enum.name }}(v)
+	return nil
+}
+
+{% endfor %}