django-cfg 1.5.14__py3-none-any.whl → 1.5.20__py3-none-any.whl

django_cfg/apps/system/frontend/views.py

@@ -130,17 +130,23 @@ class ZipExtractionMixin:
 @method_decorator(xframe_options_exempt, name='dispatch')
 class NextJSStaticView(ZipExtractionMixin, View):
     """
-    Serve Next.js static build files with automatic JWT token injection.
+    Serve Next.js static build files with automatic JWT token injection and precompression support.
 
     Features:
     - Serves Next.js static export files like a static file server
     - Smart ZIP extraction: compares ZIP metadata (size + mtime) with marker file
-    - Automatically injects JWT tokens for authenticated users
-    - Tokens injected into HTML responses only
+    - Automatically injects JWT tokens for authenticated users (HTML only)
+    - **Precompression support**: Automatically serves .br or .gz files if available
     - Handles Next.js client-side routing (.html fallback)
     - Automatically serves index.html for directory paths
     - X-Frame-Options exempt to allow embedding in iframes
 
+    Compression Strategy:
+    - Brotli (.br) preferred over Gzip (.gz) - ~5-15% better compression
+    - Automatically detects browser support via Accept-Encoding header
+    - Skips compression for HTML files (JWT injection requires uncompressed content)
+    - Only serves precompressed files, no runtime compression
+
     ZIP Extraction Logic:
     - If directory doesn't exist: extract from ZIP
     - If marker file missing: extract from ZIP
@@ -154,12 +160,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
     - /cfg/admin/private/      → /cfg/admin/private.html (fallback)
     - /cfg/admin/tasks         → /cfg/admin/tasks.html
     - /cfg/admin/tasks         → /cfg/admin/tasks/index.html (fallback)
+
+    Compression examples:
+    - _app.js (br supported)   → _app.js.br + Content-Encoding: br
+    - _app.js (gzip supported) → _app.js.gz + Content-Encoding: gzip
+    - _app.js (no support)     → _app.js (uncompressed)
+    - index.html               → index.html (never compressed, needs JWT injection)
     """
 
     app_name = 'admin'
 
     def get(self, request, path=''):
-        """Serve static files from Next.js build with JWT injection."""
+        """Serve static files from Next.js build with JWT injection and compression support."""
         import django_cfg
 
         base_dir = Path(django_cfg.__file__).parent / 'static' / 'frontend' / self.app_name
@@ -191,8 +203,18 @@ class NextJSStaticView(ZipExtractionMixin, View):
             request.META.pop('HTTP_IF_MODIFIED_SINCE', None)
             request.META.pop('HTTP_IF_NONE_MATCH', None)
 
-        # Serve the static file
-        response = serve(request, path, document_root=str(base_dir))
+        # Try to serve precompressed file if browser supports it
+        compressed_path, encoding = self._find_precompressed_file(base_dir, path, request)
+        if compressed_path:
+            logger.debug(f"[Compression] Serving {encoding} for {path}")
+            response = serve(request, compressed_path, document_root=str(base_dir))
+            response['Content-Encoding'] = encoding
+            # Remove Content-Length as it's incorrect for compressed content
+            if 'Content-Length' in response:
+                del response['Content-Length']
+        else:
+            # Serve the static file normally
+            response = serve(request, path, document_root=str(base_dir))
 
         # Convert FileResponse to HttpResponse for HTML files to enable JWT injection
         if isinstance(response, FileResponse):
@@ -222,6 +244,65 @@ class NextJSStaticView(ZipExtractionMixin, View):
 
         return response
 
+    def _find_precompressed_file(self, base_dir, path, request):
+        """
+        Find and return precompressed file (.br or .gz) if available and supported by browser.
+
+        Brotli (.br) is preferred over Gzip (.gz) as it provides better compression.
+
+        Args:
+            base_dir: Base directory for static files
+            path: Requested file path
+            request: Django request object
+
+        Returns:
+            tuple: (compressed_path, encoding) if precompressed file found and supported,
+                   (None, None) otherwise
+
+        Examples:
+            _app.js → _app.js.br (if Accept-Encoding: br)
+            _app.js → _app.js.gz (if Accept-Encoding: gzip, no .br)
+            _app.js → (None, None) (if no precompressed files or not supported)
+        """
+        # Get Accept-Encoding header
+        accept_encoding = request.META.get('HTTP_ACCEPT_ENCODING', '').lower()
+
+        # Check if browser supports brotli (preferred) or gzip
+        supports_br = 'br' in accept_encoding
+        supports_gzip = 'gzip' in accept_encoding
+
+        if not (supports_br or supports_gzip):
+            return None, None
+
+        # Don't compress HTML files - we need to inject JWT tokens
+        # JWT injection requires modifying content, which is incompatible with compression
+        if path.endswith('.html'):
+            return None, None
+
+        # Build full file path
+        file_path = base_dir / path
+
+        # Check if original file exists (safety check)
+        if not file_path.exists() or not file_path.is_file():
+            return None, None
+
+        # Try Brotli first (better compression, ~5-15% smaller than gzip)
+        if supports_br:
+            br_path = f"{path}.br"
+            br_file = base_dir / br_path
+            if br_file.exists() and br_file.is_file():
+                return br_path, 'br'
+
+        # Fallback to Gzip
+        if supports_gzip:
+            gz_path = f"{path}.gz"
+            gz_file = base_dir / gz_path
+            if gz_file.exists() and gz_file.is_file():
+                return gz_path, 'gzip'
+
+        # No precompressed file found or not supported
+        return None, None
+
     def _resolve_spa_path(self, base_dir, path):
         """
         Resolve SPA path with multiple fallback strategies.

django_cfg/core/builders/security_builder.py

@@ -323,6 +323,7 @@ class SecurityBuilder:
         """
         popular_ports = [
             3000,  # React/Next.js default
+            3777,  # Next.js Admin default
             5173,  # Vite default
             5174,  # Vite preview
             8080,  # Vue/Spring Boot

django_cfg/core/generation/integration_generators/api.py

@@ -125,6 +125,8 @@ class APIFrameworksGenerator:
                 ],
                 # Add authentication classes from smart defaults
                 "DEFAULT_AUTHENTICATION_CLASSES": drf_defaults["DEFAULT_AUTHENTICATION_CLASSES"],
+                # Force ISO 8601 datetime format with Z suffix for all datetime fields
+                "DATETIME_FORMAT": "%Y-%m-%dT%H:%M:%SZ",
             }
 
             # Note: We don't set DEFAULT_PERMISSION_CLASSES here to allow public endpoints

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

@@ -298,6 +298,14 @@ class TypeScriptGenerator(BaseGenerator):
                                 queue.append(self.context.schemas[prop.items.ref])
                                 seen.add(prop.items.ref)
 
+                    # $ref inside additionalProperties (CRITICAL for Record<string, T> patterns!)
+                    if prop.additional_properties and prop.additional_properties.ref:
+                        if prop.additional_properties.ref not in seen:
+                            if prop.additional_properties.ref in self.context.schemas:
+                                resolved[prop.additional_properties.ref] = self.context.schemas[prop.additional_properties.ref]
+                                queue.append(self.context.schemas[prop.additional_properties.ref])
+                                seen.add(prop.additional_properties.ref)
+
             # Check array items for $ref at schema level
             if schema.items and schema.items.ref:
                 if schema.items.ref not in seen:
@@ -306,6 +314,14 @@ class TypeScriptGenerator(BaseGenerator):
                         queue.append(self.context.schemas[schema.items.ref])
                         seen.add(schema.items.ref)
 
+            # Check additionalProperties for $ref at schema level
+            if schema.additional_properties and schema.additional_properties.ref:
+                if schema.additional_properties.ref not in seen:
+                    if schema.additional_properties.ref in self.context.schemas:
+                        resolved[schema.additional_properties.ref] = self.context.schemas[schema.additional_properties.ref]
+                        queue.append(self.context.schemas[schema.additional_properties.ref])
+                        seen.add(schema.additional_properties.ref)
+
         return resolved
 
     # ===== Zod Schemas Generation =====
@@ -369,11 +385,21 @@ class TypeScriptGenerator(BaseGenerator):
                         if not self.context.schemas[prop.items.ref].enum:
                             refs.add(prop.items.ref)
 
+                if prop.additional_properties and prop.additional_properties.ref:
+                    if prop.additional_properties.ref in self.context.schemas:
+                        if not self.context.schemas[prop.additional_properties.ref].enum:
+                            refs.add(prop.additional_properties.ref)
+
         if schema.items and schema.items.ref:
             if schema.items.ref in self.context.schemas:
                 if not self.context.schemas[schema.items.ref].enum:
                     refs.add(schema.items.ref)
 
+        if schema.additional_properties and schema.additional_properties.ref:
+            if schema.additional_properties.ref in self.context.schemas:
+                if not self.context.schemas[schema.additional_properties.ref].enum:
+                    refs.add(schema.additional_properties.ref)
+
         return refs
 
     # ===== Fetchers Generation =====

django_cfg/modules/django_client/core/generator/typescript/hooks_generator.py

@@ -363,6 +363,8 @@ class HooksGenerator:
         # Separate queries and mutations & collect schema names
         hooks = []
         schema_names = set()
+        has_queries = False
+        has_mutations = False
 
         for operation in operations:
             # Collect schemas used in this operation (only if they exist as components)
@@ -378,11 +380,13 @@ class HooksGenerator:
             if response and response.schema_name:
                 schema_names.add(response.schema_name)
 
-            # Generate hook
+            # Generate hook and track operation types
             if operation.http_method == "GET":
                 hooks.append(self.generate_query_hook(operation))
+                has_queries = True
             else:
                 hooks.append(self.generate_mutation_hook(operation))
+                has_mutations = True
 
         # Get display name for documentation
         tag_display_name = self.base.tag_to_display_name(tag)
@@ -398,6 +402,8 @@ class HooksGenerator:
             tag_file=tag_file,
             has_schemas=bool(schema_names),
             schema_names=sorted(schema_names),
+            has_queries=has_queries,
+            has_mutations=has_mutations,
             hooks=hooks
         )
 

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

@@ -175,8 +175,13 @@ class ModelsGenerator:
         # Handle nullable and optional separately
         # - nullable: add | null to type
         # - not required: add ? optional marker
+        # Special case: readOnly + nullable fields should be optional
+        # (they're always in response but can be null, so from client perspective they're optional)
         if schema.nullable:
             ts_type = f"{ts_type} | null"
+            # Make readOnly nullable fields optional
+            if schema.read_only:
+                is_required = False
 
         optional_marker = "" if is_required else "?"
 

django_cfg/modules/django_client/core/generator/typescript/schemas_generator.py

@@ -237,6 +237,17 @@ class SchemasGenerator:
             if schema.ref:
                 # Explicit reference
                 return f"{schema.ref}Schema"
+            elif schema.additional_properties:
+                # Object with additionalProperties (e.g., Record<string, DatabaseConfig>)
+                if schema.additional_properties.ref:
+                    value_type = f"{schema.additional_properties.ref}Schema"
+                else:
+                    value_type = self._map_type_to_zod(schema.additional_properties)
+                    # If DictField() produces additionalProperties with just string type,
+                    # use z.any() to allow mixed types (common in Django configs/settings)
+                    if value_type == "z.string()":
+                        value_type = "z.any()"
+                return f"z.record(z.string(), {value_type})"
             elif schema.properties:
                 # Inline object with properties - shouldn't reach here, but use z.object
                 return "z.object({})"

django_cfg/modules/django_client/core/generator/typescript/templates/fetchers/fetchers.ts.jinja

@@ -29,6 +29,7 @@
  * const users = await getUsers({ page: 1 }, api)
  * ```
  */
+import { consola } from 'consola'
 {% if has_schemas %}
 {% for schema_name in schema_names %}
 import { {{ schema_name }}Schema, type {{ schema_name }} } from '../schemas/{{ schema_name }}.schema'

django_cfg/modules/django_client/core/generator/typescript/templates/fetchers/function.ts.jinja

@@ -17,7 +17,35 @@ export async function {{ func_name }}(
   const response = await {{ api_call }}()
 {% endif %}
 {% if response_schema %}
-  return {{ response_schema }}.parse(response)
+  try {
+    return {{ response_schema }}.parse(response)
+  } catch (error) {
+    // Zod validation error - log detailed information
+    consola.error('❌ Zod Validation Failed');
+    consola.box({
+      title: '{{ func_name }}',
+      message: `Path: {{ operation.path }}\nMethod: {{ operation.http_method }}`,
+      style: {
+        borderColor: 'red',
+        borderStyle: 'rounded'
+      }
+    });
+
+    if (error instanceof Error && 'issues' in error && Array.isArray((error as any).issues)) {
+      consola.error('Validation Issues:');
+      (error as any).issues.forEach((issue: any, index: number) => {
+        consola.error(`  ${index + 1}. ${issue.path.join('.') || 'root'}`);
+        consola.error(`     ├─ Message: ${issue.message}`);
+        if (issue.expected) consola.error(`     ├─ Expected: ${issue.expected}`);
+        if (issue.received) consola.error(`     └─ Received: ${issue.received}`);
+      });
+    }
+
+    consola.error('Response data:', response);
+
+    // Re-throw the error
+    throw error;
+  }
 {% else %}
   return response
 {% endif %}

django_cfg/modules/django_client/core/generator/typescript/templates/hooks/hooks.ts.jinja

@@ -14,8 +14,12 @@
  * await createUser({ name: 'John', email: 'john@example.com' })
  * ```
  */
+{% if has_queries %}
 import useSWR from 'swr'
+{% endif %}
+{% if has_mutations %}
 import { useSWRConfig } from 'swr'
+{% endif %}
 import * as Fetchers from '../fetchers/{{ tag_file }}'
 import type { API } from '../../index'
 {% if has_schemas %}

django_cfg/modules/django_client/core/ir/schema.py

@@ -103,6 +103,10 @@ class IRSchemaObject(BaseModel):
         default_factory=list,
         description="Required property names",
     )
+    additional_properties: IRSchemaObject | None = Field(
+        None,
+        description="Schema for additional properties (for dynamic keys in object, e.g., Record<string, T>)",
+    )
 
     # ===== Array Items =====
     items: IRSchemaObject | None = Field(
@@ -322,8 +326,11 @@ class IRSchemaObject(BaseModel):
             >>> IRSchemaObject(name="file", type="string", format="binary").typescript_type
             'File | Blob'
         """
+        # Handle $ref (e.g., CentrifugoConfig, User, etc.)
+        if self.ref:
+            base_type = self.ref
         # Handle binary type (file uploads)
-        if self.is_binary:
+        elif self.is_binary:
             base_type = "File | Blob"
         # Handle array type with proper item type resolution
         elif self.type == "array":
@@ -336,6 +343,13 @@ class IRSchemaObject(BaseModel):
                 base_type = f"Array<{item_type}>"
             else:
                 base_type = "Array<any>"
+        # Handle object with additionalProperties (e.g., Record<string, DatabaseConfig>)
+        elif self.type == "object" and self.additional_properties:
+            if self.additional_properties.ref:
+                value_type = self.additional_properties.ref
+            else:
+                value_type = self.additional_properties.typescript_type
+            base_type = f"Record<string, {value_type}>"
         else:
             type_map = {
                 "string": "string",

django_cfg/modules/django_client/core/parser/base.py

@@ -453,6 +453,17 @@ class BaseParser(ABC):
             else:
                 items = self._parse_schema(f"{name}.items", schema.items)
 
+        # Parse additionalProperties (for Record<string, T> types)
+        additional_properties = None
+        if schema.additionalProperties and not isinstance(schema.additionalProperties, bool):
+            if isinstance(schema.additionalProperties, ReferenceObject):
+                # Resolve reference (e.g., Record<string, DatabaseConfig>)
+                additional_properties = self._resolve_ref(schema.additionalProperties)
+            else:
+                additional_properties = self._parse_schema(
+                    f"{name}.additionalProperties", schema.additionalProperties
+                )
+
         # Create IR schema
         ir_schema = IRSchemaObject(
             name=name,
@@ -462,6 +473,7 @@ class BaseParser(ABC):
             nullable=self._detect_nullable(schema),
             properties=properties,
             required=schema.required or [],
+            additional_properties=additional_properties,
             items=items,
             enum=schema.enum,
             enum_var_names=schema.x_enum_varnames,

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.5.14"
+version = "1.5.20"
 description = "Modern Django framework with type-safe Pydantic v2 configuration, Next.js admin integration, real-time WebSockets, and 8 enterprise apps. Replace settings.py with validated models, 90% less code. Production-ready with AI agents, auto-generated TypeScript clients, and zero-config features."
 readme = "README.md"
 keywords = [ "django", "configuration", "pydantic", "settings", "type-safety", "pydantic-settings", "django-environ", "startup-validation", "ide-autocomplete", "nextjs-admin", "react-admin", "websocket", "centrifugo", "real-time", "typescript-generation", "ai-agents", "enterprise-django", "django-settings", "type-safe-config", "modern-django",]

{django_cfg-1.5.14.dist-info → django_cfg-1.5.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.5.14
+Version: 1.5.20
 Summary: Modern Django framework with type-safe Pydantic v2 configuration, Next.js admin integration, real-time WebSockets, and 8 enterprise apps. Replace settings.py with validated models, 90% less code. Production-ready with AI agents, auto-generated TypeScript clients, and zero-config features.
 Project-URL: Homepage, https://djangocfg.com
 Project-URL: Documentation, https://djangocfg.com