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

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/management/commands/generate_client.py

@@ -14,7 +14,7 @@ from django.core.management.base import BaseCommand, CommandError
 class Command(BaseCommand):
     """Generate OpenAPI clients for configured application groups."""
 
-    help = "Generate Python and TypeScript API clients from OpenAPI schemas"
+    help = "Generate Python, TypeScript, and Go API clients from OpenAPI schemas"
 
     def add_arguments(self, parser):
         """Add command arguments."""
@@ -37,6 +37,12 @@ class Command(BaseCommand):
             help="Generate TypeScript client only",
         )
 
+        parser.add_argument(
+            "--go",
+            action="store_true",
+            help="Generate Go client only",
+        )
+
         parser.add_argument(
             "--no-python",
             action="store_true",
@@ -49,6 +55,12 @@ class Command(BaseCommand):
             help="Skip TypeScript client generation",
         )
 
+        parser.add_argument(
+            "--no-go",
+            action="store_true",
+            help="Skip Go client generation",
+        )
+
         # Utility options
         parser.add_argument(
             "--dry-run",
@@ -193,15 +205,22 @@ class Command(BaseCommand):
     def _generate_clients(self, service, options):
         """Generate clients."""
         # Determine languages
-        if options["python"] and not options["typescript"]:
+        if options["python"] and not options["typescript"] and not options["go"]:
             python = True
             typescript = False
-        elif options["typescript"] and not options["python"]:
+            go = False
+        elif options["typescript"] and not options["python"] and not options["go"]:
             python = False
             typescript = True
+            go = False
+        elif options["go"] and not options["python"] and not options["typescript"]:
+            python = False
+            typescript = False
+            go = True
         else:
             python = not options["no_python"]
             typescript = not options["no_typescript"]
+            go = not options["no_go"]
 
         # Get groups
         groups = options.get("groups")
@@ -233,6 +252,8 @@ class Command(BaseCommand):
             self.stdout.write("  → Python")
         if typescript:
             self.stdout.write("  → TypeScript")
+        if go:
+            self.stdout.write("  → Go")
 
         if dry_run:
             self.stdout.write(self.style.WARNING("\n✅ Dry run completed - no files generated"))
@@ -248,6 +269,7 @@ class Command(BaseCommand):
 
         from django_cfg.modules.django_client.core import (
             ArchiveManager,
+            GoGenerator,
             GroupManager,
             PythonGenerator,
             TypeScriptGenerator,
@@ -395,6 +417,32 @@ class Command(BaseCommand):
 
                     self.stdout.write(f"  ✅ TypeScript client: {ts_dir} ({len(ts_files)} files)")
 
+                # Generate Go client
+                if go:
+                    self.stdout.write("  → Generating Go client...")
+                    go_dir = service.config.get_group_go_dir(group_name)
+                    go_dir.mkdir(parents=True, exist_ok=True)
+
+                    go_generator = GoGenerator(
+                        ir_context,
+                        client_structure=service.config.client_structure,
+                        openapi_schema=schema_dict,
+                        tag_prefix=f"{group_name}_",
+                        generate_package_files=service.config.generate_package_files,
+                        package_config={
+                            "module_name": f"djangocfg__{group_name}",
+                            "version": "v1.0.0",
+                        },
+                    )
+                    go_files = go_generator.generate()
+
+                    for generated_file in go_files:
+                        full_path = go_dir / generated_file.path
+                        full_path.parent.mkdir(parents=True, exist_ok=True)
+                        full_path.write_text(generated_file.content)
+
+                    self.stdout.write(f"  ✅ Go client: {go_dir} ({len(go_files)} files)")
+
                 # Archive if enabled
                 if service.config.enable_archive:
                     self.stdout.write("  → Archiving...")
@@ -428,3 +476,5 @@ class Command(BaseCommand):
             self.stdout.write(f"  Python:     {service.config.get_python_clients_dir()}")
         if typescript:
             self.stdout.write(f"  TypeScript: {service.config.get_typescript_clients_dir()}")
+        if go:
+            self.stdout.write(f"  Go:         {service.config.get_go_clients_dir()}")

django_cfg/modules/django_client/system/generate_mjs_clients.py

@@ -54,7 +54,9 @@ def main():
     django_cfg_dir = modules_dir.parent  # django_cfg
     src_dir = django_cfg_dir.parent  # src
     dev_dir = src_dir.parent  # django-cfg-dev
-    example_django_dir = dev_dir.parent / "solution" / "projects" / "django"
+    projects_dir = dev_dir.parent  # projects
+    root_dir = projects_dir.parent  # root (django-cfg)
+    example_django_dir = root_dir / "solution" / "projects" / "django"
 
     # Output directory for MJS clients
     if args.output:

django_cfg/modules/django_client/system/schema_parser.py

@@ -120,7 +120,11 @@ class SchemaParser:
                 return 'Object'
             # Check for additionalProperties (dictionary-like)
             if 'additionalProperties' in schema:
-                value_type = self.get_js_type(schema['additionalProperties'])
+                additional = schema['additionalProperties']
+                # additionalProperties can be bool or schema object
+                if isinstance(additional, bool):
+                    return 'Record<string, any>' if additional else 'Object'
+                value_type = self.get_js_type(additional)
                 return f'Record<string, {value_type}>'
             return 'Object'
 

django_cfg/modules/django_tailwind/templates/django_tailwind/base.html

@@ -13,6 +13,7 @@
 
     <!-- Alpine.js for interactivity -->
     <script defer src="https://unpkg.com/alpinejs@3.x.x/dist/cdn.min.js"></script>
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
 
     <style>
         /* Prevent flash of unstyled content */

django_cfg/modules/django_twilio/sendgrid_service.py

@@ -17,6 +17,7 @@ from django.template.loader import render_to_string
 from sendgrid import SendGridAPIClient
 from sendgrid.helpers.mail import Mail
 
+from django_cfg.core.utils import get_otp_url
 from django_cfg.modules.base import BaseCfgModule
 from django_cfg.modules.django_twilio.exceptions import (
     TwilioConfigurationError,
@@ -305,6 +306,9 @@ class SendGridService(BaseCfgModule):
             # Prepare subject
             subject = f"Your {cfg.project_name if cfg else 'Django CFG'} verification code"
 
+            # Generate OTP link using utility function
+            otp_link = get_otp_url(otp_code)
+
             # Prepare template data matching sendgrid_otp_email.html template
             dynamic_data = {
                 'site_name': cfg.project_name if cfg else 'Django CFG',
@@ -317,7 +321,7 @@ class SendGridService(BaseCfgModule):
                     'email': email
                 },
                 'otp_code': otp_code,  # This is what the template expects!
-                'otp_link': cfg.get_otp_url(otp_code) if cfg else None,  # Add OTP verification link
+                'otp_link': otp_link,  # Add OTP verification link
                 'expires_minutes': 10,
                 'subject': subject,  # Add subject to template data
                 **config.custom_template_data,
@@ -370,9 +374,8 @@ class SendGridService(BaseCfgModule):
                 "user": {"username": email.split("@")[0]},  # Fallback user object
             }
 
-            # Add OTP link if config is available
-            if current_config:
-                context["otp_link"] = current_config.get_otp_url(otp_code)
+            # Add OTP link using utility function
+            context["otp_link"] = get_otp_url(otp_code)
 
             # Render Django templates
             try:

django_cfg/modules/django_unfold/dashboard.py

@@ -68,16 +68,22 @@ class DashboardManager(BaseCfgModule):
             ),
         ]
 
+        # Centrifugo Dashboard (if enabled)
+        if self.is_centrifugo_enabled():
+            navigation_sections.append(
+                NavigationSection(
+                    title="Centrifugo",
+                    separator=True,
+                    collapsible=True,
+                    items=[NavigationItem(title="Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/centrifugo/admin/"),
+                    NavigationItem(title="Logs", icon=Icons.LIST_ALT, link=str(reverse_lazy("admin:django_cfg_centrifugo_centrifugolog_changelist"))),
+                ]
+            )
+        )
+
         # Add Operations section (System & Monitoring tools)
         operations_items = []
 
-        # RPC Dashboard (if enabled)
-        if self.is_rpc_enabled():
-            operations_items.extend([
-                NavigationItem(title="IPC/RPC Dashboard", icon=Icons.MONITOR_HEART, link="/cfg/ipc/admin/"),
-                NavigationItem(title="RPC Logs", icon=Icons.LIST_ALT, link=str(reverse_lazy("admin:django_cfg_ipc_rpclog_changelist"))),
-            ])
-
         # Background Tasks (if enabled)
         if self.should_enable_tasks():
             operations_items.extend([
@@ -327,38 +333,38 @@ class DashboardManager(BaseCfgModule):
         )
         widgets.append(system_overview_widget.to_dict())
 
-        # Add RPC monitoring widget if IPC is enabled
-        if self.is_rpc_enabled():
-            rpc_monitoring_widget = StatsCardsWidget(
-                title="IPC/RPC Monitoring",
+        # Add Centrifugo monitoring widget if enabled
+        if self.is_centrifugo_enabled():
+            centrifugo_monitoring_widget = StatsCardsWidget(
+                title="Centrifugo Monitoring",
                 cards=[
                     StatCard(
-                        title="Total Calls",
-                        value="{{ rpc_total_calls }}",
+                        title="Total Publishes",
+                        value="{{ centrifugo_total_publishes }}",
                         icon=Icons.API,
                         color="blue",
                     ),
                     StatCard(
                         title="Success Rate",
-                        value="{{ rpc_success_rate }}%",
+                        value="{{ centrifugo_success_rate }}%",
                         icon=Icons.CHECK_CIRCLE,
                         color="green",
                     ),
                     StatCard(
-                        title="Avg Response Time",
-                        value="{{ rpc_avg_duration }}ms",
+                        title="Avg Duration",
+                        value="{{ centrifugo_avg_duration }}ms",
                         icon=Icons.SPEED,
                         color="purple",
                     ),
                     StatCard(
-                        title="Failed Calls",
-                        value="{{ rpc_failed_calls }}",
+                        title="Failed Publishes",
+                        value="{{ centrifugo_failed_publishes }}",
                         icon=Icons.ERROR,
                         color="red",
                     ),
                 ]
             )
-            widgets.append(rpc_monitoring_widget.to_dict())
+            widgets.append(centrifugo_monitoring_widget.to_dict())
 
         # Convert to dictionaries for Unfold
         return widgets

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.62"
+version = "1.4.64"
 description = "Django AI framework with built-in agents, type-safe Pydantic v2 configuration, and 8 enterprise apps. Replace settings.py, validate at startup, 90% less code. Production-ready AI workflows for Django."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "ai-agents", "enterprise-django", "django-settings", "type-safe-config",]

django_cfg/registry/core.py

@@ -61,6 +61,8 @@ CORE_REGISTRY = {
 
     # Utils
     "version_check": ("django_cfg.utils.version_check", "version_check"),
+    "get_ticket_url": ("django_cfg.core.utils.url_helpers", "get_ticket_url"),
+    "get_otp_url": ("django_cfg.core.utils.url_helpers", "get_otp_url"),
 
     # Routing
     "DynamicRouter": ("django_cfg.routing.routers", "DynamicRouter"),

django_cfg/registry/modules.py

@@ -10,8 +10,8 @@ MODULES_REGISTRY = {
     # Configuration utilities
     "set_current_config": ("django_cfg.core.config", "set_current_config"),
 
-    # IPC/RPC module
-    "DjangoCfgRPCConfig": ("django_cfg.apps.ipc", "DjangoCfgRPCConfig"),
+    # Centrifugo module
+    "DjangoCfgCentrifugoConfig": ("django_cfg.apps.centrifugo.services.client.config", "DjangoCfgCentrifugoConfig"),
 
     # Import/Export integration (simple re-exports)
     "ImportForm": ("django_cfg.modules.django_import_export", "ImportForm"),