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

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

@@ -0,0 +1,217 @@
+// Code generated by django-cfg/django_client - DO NOT EDIT.
+// Generated at: {{ generated_at }}
+
+package {{ package_name }}
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+)
+
+// ValidationError represents a validation error.
+type ValidationError struct {
+	Field   string
+	Message string
+}
+
+// Error implements the error interface.
+func (e *ValidationError) Error() string {
+	return fmt.Sprintf("validation error on field '%s': %s", e.Field, e.Message)
+}
+
+// ValidationErrors represents multiple validation errors.
+type ValidationErrors []ValidationError
+
+// Error implements the error interface.
+func (e ValidationErrors) Error() string {
+	if len(e) == 0 {
+		return "validation errors"
+	}
+
+	var messages []string
+	for _, err := range e {
+		messages = append(messages, err.Error())
+	}
+	return strings.Join(messages, "; ")
+}
+
+// Add adds a validation error.
+func (e *ValidationErrors) Add(field, message string) {
+	*e = append(*e, ValidationError{
+		Field:   field,
+		Message: message,
+	})
+}
+
+// HasErrors returns true if there are any errors.
+func (e ValidationErrors) HasErrors() bool {
+	return len(e) > 0
+}
+
+// Validator provides validation utilities.
+type Validator struct {
+	errors ValidationErrors
+}
+
+// NewValidator creates a new validator.
+func NewValidator() *Validator {
+	return &Validator{
+		errors: make(ValidationErrors, 0),
+	}
+}
+
+// Required validates that a string field is not empty.
+func (v *Validator) Required(field, value string) *Validator {
+	if strings.TrimSpace(value) == "" {
+		v.errors.Add(field, "this field is required")
+	}
+	return v
+}
+
+// RequiredInt validates that an int field is set (non-zero).
+func (v *Validator) RequiredInt(field string, value int64) *Validator {
+	if value == 0 {
+		v.errors.Add(field, "this field is required")
+	}
+	return v
+}
+
+// RequiredPtr validates that a pointer field is not nil.
+func (v *Validator) RequiredPtr(field string, value interface{}) *Validator {
+	if value == nil {
+		v.errors.Add(field, "this field is required")
+	}
+	return v
+}
+
+// MinLength validates minimum string length.
+func (v *Validator) MinLength(field, value string, min int) *Validator {
+	if len(value) > 0 && len(value) < min {
+		v.errors.Add(field, fmt.Sprintf("must be at least %d characters", min))
+	}
+	return v
+}
+
+// MaxLength validates maximum string length.
+func (v *Validator) MaxLength(field, value string, max int) *Validator {
+	if len(value) > max {
+		v.errors.Add(field, fmt.Sprintf("must be at most %d characters", max))
+	}
+	return v
+}
+
+// MinValue validates minimum numeric value.
+func (v *Validator) MinValue(field string, value, min int64) *Validator {
+	if value < min {
+		v.errors.Add(field, fmt.Sprintf("must be at least %d", min))
+	}
+	return v
+}
+
+// MaxValue validates maximum numeric value.
+func (v *Validator) MaxValue(field string, value, max int64) *Validator {
+	if value > max {
+		v.errors.Add(field, fmt.Sprintf("must be at most %d", max))
+	}
+	return v
+}
+
+// Pattern validates string against regex pattern.
+func (v *Validator) Pattern(field, value, pattern, message string) *Validator {
+	if value == "" {
+		return v
+	}
+
+	matched, err := regexp.MatchString(pattern, value)
+	if err != nil {
+		v.errors.Add(field, fmt.Sprintf("invalid pattern: %v", err))
+		return v
+	}
+
+	if !matched {
+		if message == "" {
+			message = fmt.Sprintf("must match pattern: %s", pattern)
+		}
+		v.errors.Add(field, message)
+	}
+
+	return v
+}
+
+// Email validates email format.
+func (v *Validator) Email(field, value string) *Validator {
+	if value == "" {
+		return v
+	}
+
+	// Simple email validation
+	pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
+	return v.Pattern(field, value, pattern, "must be a valid email address")
+}
+
+// URL validates URL format.
+func (v *Validator) URL(field, value string) *Validator {
+	if value == "" {
+		return v
+	}
+
+	if !strings.HasPrefix(value, "http://") && !strings.HasPrefix(value, "https://") {
+		v.errors.Add(field, "must be a valid URL starting with http:// or https://")
+	}
+
+	return v
+}
+
+// OneOf validates that value is one of allowed values.
+func (v *Validator) OneOf(field, value string, allowed []string) *Validator {
+	if value == "" {
+		return v
+	}
+
+	for _, a := range allowed {
+		if value == a {
+			return v
+		}
+	}
+
+	v.errors.Add(field, fmt.Sprintf("must be one of: %s", strings.Join(allowed, ", ")))
+	return v
+}
+
+// Custom adds a custom validation error.
+func (v *Validator) Custom(field, message string) *Validator {
+	v.errors.Add(field, message)
+	return v
+}
+
+// CustomIf adds a custom validation error if condition is true.
+func (v *Validator) CustomIf(condition bool, field, message string) *Validator {
+	if condition {
+		v.errors.Add(field, message)
+	}
+	return v
+}
+
+// Errors returns all validation errors.
+func (v *Validator) Errors() ValidationErrors {
+	return v.errors
+}
+
+// Valid returns true if there are no validation errors.
+func (v *Validator) Valid() bool {
+	return !v.errors.HasErrors()
+}
+
+// Error returns validation errors as an error, or nil if valid.
+func (v *Validator) Error() error {
+	if v.Valid() {
+		return nil
+	}
+	return v.errors
+}
+
+// Validate is a convenience function to create and return a validator.
+func Validate() *Validator {
+	return NewValidator()
+}

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

@@ -0,0 +1,380 @@
+"""
+Type mapping from OpenAPI/IR to Go types.
+
+Handles conversion of IR schemas to Go types with proper handling of:
+- Primitive types (string, integer, number, boolean)
+- Optional fields (pointers)
+- Arrays and slices
+- Nested objects (struct references)
+- Enums (custom types)
+- Format-specific types (time.Time, uuid, etc.)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .naming import sanitize_go_identifier, to_pascal_case
+
+if TYPE_CHECKING:
+    from ...ir import IRSchemaObject
+
+
+class GoTypeMapper:
+    """
+    Maps OpenAPI/IR types to Go types.
+
+    Handles:
+    - Primitive types (string → string, integer → int64, etc.)
+    - Optional fields (User.email? → *string)
+    - Arrays ([]string, []int64)
+    - Nested objects (references to other structs)
+    - Enums (custom types with constants)
+    """
+
+    # Primitive type mapping
+    PRIMITIVE_TYPES = {
+        "string": "string",
+        "integer": "int64",
+        "number": "float64",
+        "boolean": "bool",
+        "object": "map[string]interface{}",
+        "null": "interface{}",
+    }
+
+    # Format-specific type overrides
+    FORMAT_OVERRIDES = {
+        "int32": "int32",
+        "int64": "int64",
+        "float": "float32",
+        "double": "float64",
+        "date-time": "time.Time",
+        "date": "string",  # YYYY-MM-DD format
+        "uuid": "string",  # Or use google/uuid package
+        "binary": "[]byte",
+        "byte": "[]byte",
+        "email": "string",
+        "uri": "string",
+        "url": "string",
+        "hostname": "string",
+        "ipv4": "string",
+        "ipv6": "string",
+    }
+
+    def __init__(self, use_types_package: bool = False):
+        """Initialize type mapper.
+
+        Args:
+            use_types_package: If True, prefix enum types with "types."
+        """
+        self._imports_needed = set()
+        self.use_types_package = use_types_package
+
+    def get_imports(self) -> set[str]:
+        """
+        Get required imports for generated code.
+
+        Returns:
+            Set of import paths (e.g., {"time", "encoding/json"})
+        """
+        return self._imports_needed
+
+    def ir_schema_to_go_type(
+        self,
+        schema: IRSchemaObject,
+        required: bool = True,
+        parent_schema: IRSchemaObject | None = None,
+    ) -> str:
+        """
+        Convert IR schema to Go type.
+
+        Args:
+            schema: IRSchemaObject to convert
+            required: Whether field is required (affects pointer usage)
+            parent_schema: Parent schema (for context)
+
+        Returns:
+            Go type string
+
+        Examples:
+            >>> mapper.ir_schema_to_go_type(
+            ...     IRSchemaObject(name="email", type="string"),
+            ...     required=False
+            ... )
+            '*string'
+
+            >>> mapper.ir_schema_to_go_type(
+            ...     IRSchemaObject(name="items", type="array", items=IRSchemaObject(type="string"))
+            ... )
+            '[]string'
+
+            >>> mapper.ir_schema_to_go_type(
+            ...     IRSchemaObject(name="created_at", type="string", format="date-time")
+            ... )
+            'time.Time'
+        """
+        # Handle $ref
+        if schema.ref:
+            type_name = schema.ref.split('/')[-1]
+            # Struct references are already pointers in Go when optional
+            if not required:
+                return f"*{type_name}"
+            return type_name
+
+        # Handle enums
+        if schema.enum:
+            enum_type = self._get_enum_type_name(schema)
+            if self.use_types_package:
+                enum_type = f"types.{enum_type}"
+            return f"*{enum_type}" if not required else enum_type
+
+        # Handle arrays
+        if schema.type == "array" and schema.items:
+            item_type = self.ir_schema_to_go_type(schema.items, required=True)
+            # Arrays are always non-nil in Go, but can be empty
+            # omitempty in JSON tag handles the serialization
+            return f"[]{item_type}"
+
+        # Handle format overrides
+        if schema.format and schema.format in self.FORMAT_OVERRIDES:
+            go_type = self.FORMAT_OVERRIDES[schema.format]
+
+            # Track imports
+            if go_type == "time.Time":
+                self._imports_needed.add("time")
+
+            # time.Time is a struct, so we use pointer for optionals
+            if not required:
+                return f"*{go_type}"
+            return go_type
+
+        # Handle primitive types
+        if schema.type in self.PRIMITIVE_TYPES:
+            go_type = self.PRIMITIVE_TYPES[schema.type]
+
+            # Optionals become pointers (except for maps and interfaces)
+            if not required and go_type not in ["interface{}", "map[string]interface{}"]:
+                return f"*{go_type}"
+
+            return go_type
+
+        # Fallback to interface{} for unknown types
+        return "interface{}"
+
+    def ir_schema_to_struct(
+        self,
+        schema: IRSchemaObject,
+    ) -> dict:
+        """
+        Convert IR schema to Go struct definition.
+
+        Args:
+            schema: IRSchemaObject to convert
+
+        Returns:
+            Dictionary with struct definition:
+            {
+                "name": "User",
+                "fields": [
+                    {
+                        "name": "ID",
+                        "type": "int64",
+                        "json_tag": '`json:"id"`',
+                        "description": "User ID",
+                        "required": True
+                    },
+                    ...
+                ],
+                "doc": "User represents a registered user.",
+                "needs_time_import": False,
+            }
+
+        Examples:
+            >>> schema = IRSchemaObject(
+            ...     name="User",
+            ...     type="object",
+            ...     properties={
+            ...         "id": IRSchemaObject(name="id", type="integer"),
+            ...         "username": IRSchemaObject(name="username", type="string"),
+            ...         "email": IRSchemaObject(name="email", type="string"),
+            ...     },
+            ...     required=["id", "username"],
+            ... )
+            >>> struct = mapper.ir_schema_to_struct(schema)
+            >>> struct["name"]
+            'User'
+            >>> len(struct["fields"])
+            3
+        """
+        fields = []
+
+        # Reset imports for this struct
+        self._imports_needed = set()
+
+        # Process properties
+        for prop_name, prop_schema in (schema.properties or {}).items():
+            is_required = prop_name in (schema.required or [])
+
+            # Get Go type
+            go_type = self.ir_schema_to_go_type(prop_schema, is_required, parent_schema=schema)
+
+            # Build JSON tag
+            if not is_required:
+                json_tag = f'`json:"{prop_name},omitempty"`'
+            else:
+                json_tag = f'`json:"{prop_name}"`'
+
+            # Create field definition
+            field = {
+                "name": to_pascal_case(prop_name),
+                "type": go_type,
+                "json_tag": json_tag,
+                "description": prop_schema.description or "",
+                "required": is_required,
+                "deprecated": prop_schema.deprecated,
+            }
+            fields.append(field)
+
+        return {
+            "name": schema.name,
+            "fields": fields,
+            "doc": schema.description or f"{schema.name} model.",
+            "needs_time_import": "time" in self._imports_needed,
+        }
+
+    def _get_enum_type_name(self, schema: IRSchemaObject) -> str:
+        """
+        Get enum type name from schema.
+
+        Args:
+            schema: IRSchemaObject with enum
+
+        Returns:
+            Enum type name (PascalCase)
+
+        Examples:
+            >>> schema = IRSchemaObject(name="status", type="integer", enum=[1, 2, 3])
+            >>> mapper._get_enum_type_name(schema)
+            'Status'
+
+            >>> schema = IRSchemaObject(name="User.role", type="string", enum=["admin", "user"])
+            >>> mapper._get_enum_type_name(schema)
+            'UserRole'
+        """
+        if not schema.name:
+            return "Enum"
+
+        # Handle nested enum names (e.g., "User.role" → "UserRole")
+        if '.' in schema.name:
+            parts = schema.name.split('.')
+            return ''.join(to_pascal_case(p) for p in parts)
+
+        return to_pascal_case(schema.name)
+
+    def get_enum_base_type(self, schema: IRSchemaObject) -> str:
+        """
+        Get Go base type for enum.
+
+        Args:
+            schema: IRSchemaObject with enum
+
+        Returns:
+            Go base type ("int64", "string", etc.)
+
+        Examples:
+            >>> schema = IRSchemaObject(name="status", type="integer", enum=[1, 2, 3])
+            >>> mapper.get_enum_base_type(schema)
+            'int64'
+
+            >>> schema = IRSchemaObject(name="role", type="string", enum=["admin", "user"])
+            >>> mapper.get_enum_base_type(schema)
+            'string'
+        """
+        if schema.type == "integer":
+            # Check format for int32 vs int64
+            if schema.format == "int32":
+                return "int32"
+            return "int64"
+        elif schema.type == "number":
+            if schema.format == "float":
+                return "float32"
+            return "float64"
+        elif schema.type == "string":
+            return "string"
+
+        # Default to int64
+        return "int64"
+
+    def generate_enum_definition(self, schema: IRSchemaObject) -> dict:
+        """
+        Generate enum type definition for Go.
+
+        Args:
+            schema: IRSchemaObject with enum + enum_var_names
+
+        Returns:
+            Dictionary with enum definition:
+            {
+                "name": "StatusEnum",
+                "base_type": "int64",
+                "values": [
+                    {"name": "StatusNew", "value": 1, "description": "New user"},
+                    {"name": "StatusActive", "value": 2, "description": "Active user"},
+                ],
+                "doc": "StatusEnum represents user status.",
+            }
+
+        Examples:
+            >>> schema = IRSchemaObject(
+            ...     name="status",
+            ...     type="integer",
+            ...     enum=[1, 2, 3],
+            ...     enum_var_names=["STATUS_NEW", "STATUS_ACTIVE", "STATUS_COMPLETE"],
+            ... )
+            >>> enum_def = mapper.generate_enum_definition(schema)
+            >>> enum_def["name"]
+            'Status'
+            >>> len(enum_def["values"])
+            3
+        """
+        enum_type_name = self._get_enum_type_name(schema)
+        base_type = self.get_enum_base_type(schema)
+
+        # Build enum values
+        values = []
+        enum_values = schema.enum or []
+        enum_var_names = schema.enum_var_names or []
+
+        for i, enum_value in enumerate(enum_values):
+            # Get variable name
+            if i < len(enum_var_names):
+                # Even if var name is provided, sanitize it for Go
+                var_name = sanitize_go_identifier(enum_var_names[i])
+            else:
+                # Auto-generate from value
+                if isinstance(enum_value, str):
+                    # Use sanitize_go_identifier to handle dots, hyphens, spaces, etc.
+                    var_name = sanitize_go_identifier(enum_value)
+                else:
+                    var_name = f"VALUE_{enum_value}"
+
+            # var_name is now always PascalCase from sanitize_go_identifier
+            go_var_name = var_name
+
+            # Add enum type prefix if not present
+            if not go_var_name.startswith(enum_type_name):
+                go_var_name = enum_type_name + go_var_name
+
+            values.append({
+                "name": go_var_name,
+                "value": enum_value,
+                "description": "",  # Could extract from x-choices if available
+            })
+
+        return {
+            "name": enum_type_name,
+            "base_type": base_type,
+            "values": values,
+            "doc": schema.description or f"{enum_type_name} enum.",
+            "is_string_enum": schema.type == "string",
+        }

django_cfg/modules/django_client/core/generator/proto/__init__.py

@@ -0,0 +1,17 @@
+"""
+Proto Generator Module - Protocol Buffer/gRPC code generation.
+
+Generates .proto files from OpenAPI/IR for gRPC client generation.
+"""
+
+from .generator import ProtoGenerator
+from .messages_generator import ProtoMessagesGenerator
+from .services_generator import ProtoServicesGenerator
+from .type_mapper import ProtoTypeMapper
+
+__all__ = [
+    "ProtoGenerator",
+    "ProtoTypeMapper",
+    "ProtoMessagesGenerator",
+    "ProtoServicesGenerator",
+]