django-cfg 1.4.108__py3-none-any.whl → 1.4.109__py3-none-any.whl

django_cfg/__init__.py

@@ -32,7 +32,7 @@ Example:
 default_app_config = "django_cfg.apps.DjangoCfgConfig"
 
 # Version information
-__version__ = "1.4.108"
+__version__ = "1.4.109"
 __license__ = "MIT"
 
 # Import registry for organized lazy loading

django_cfg/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "django-cfg"
-version = "1.4.108"
+version = "1.4.109"
 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.4.108.dist-info → django_cfg-1.4.109.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-cfg
-Version: 1.4.108
+Version: 1.4.109
 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

{django_cfg-1.4.108.dist-info → django_cfg-1.4.109.dist-info}/RECORD

@@ -1,5 +1,5 @@
 django_cfg/README.md,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-django_cfg/__init__.py,sha256=IOva6NUiepfrbs-A0jIjuXF_Ukn76RAB97unffae6Tw,1621
+django_cfg/__init__.py,sha256=fOg2eKyhb6AAON0Y5yU5AoTiDjb3u-C0JommQ8cTqgg,1621
 django_cfg/apps.py,sha256=72m3uuvyqGiLx6gOfE-BD3P61jddCCERuBOYpxTX518,1605
 django_cfg/config.py,sha256=y4Z3rnYsHBE0TehpwAIPaxr---mkvyKrZGGsNwYso74,1398
 django_cfg/apps/__init__.py,sha256=JtDmEYt1OcleWM2ZaeX0LKDnRQzPOavfaXBWG4ECB5Q,26
@@ -845,16 +845,6 @@ django_cfg/modules/django_client/spectacular/__init__.py,sha256=M8fG-odu2ltkG36a
 django_cfg/modules/django_client/spectacular/async_detection.py,sha256=S_pwGR7_2SIWHjZJyiu7SCfySF3Nr3P8eqjDyBSkkLs,5731
 django_cfg/modules/django_client/spectacular/enum_naming.py,sha256=FMJyJiS7nBs-Q9yDs5M0qsNLVX8UJhFgJK9Svo-T2tk,6486
 django_cfg/modules/django_client/spectacular/schema.py,sha256=6oJxoNsSsZLlM2qmKuJGU1sPPyEGr1Xit_xBfLvprHU,1639
-django_cfg/modules/django_client/system/__init__.py,sha256=uDARdYmmJ2yR0pCNaIQpsAPcErvhO7FNYX0CTbow8Y8,622
-django_cfg/modules/django_client/system/base_generator.py,sha256=skEf8_vXz3AeHZqOg_BjqsL1AToPn-RQY0211-ZXncM,4396
-django_cfg/modules/django_client/system/generate_mjs_clients.py,sha256=N8GsRUgrSJ4MaiJ99q5tvYg3K7OStF6VjjZO5J-7woQ,5749
-django_cfg/modules/django_client/system/mjs_generator.py,sha256=c6ktFR8Ipuju3CGPe6NUnlBwiqPrT_ik1ysRsBcd9Nw,7351
-django_cfg/modules/django_client/system/schema_parser.py,sha256=0IzTKcSEWDDe4FkAqNOSWG4MQTbQzg-bAXHOV0v3sZs,7216
-django_cfg/modules/django_client/system/templates/api_client.js.j2,sha256=u3CLl4LVNgGrusuhiY8Q7btWpwkF2ijYxtZmFCsbBfk,2803
-django_cfg/modules/django_client/system/templates/app_index.js.j2,sha256=PPxiIaYw7U5VeMv5bySu3srxFHRBwo5mt1yL-l1SZ_0,387
-django_cfg/modules/django_client/system/templates/base_client.js.j2,sha256=Qjngf8783y47FnQ0ZOvtdFTSF6t-vYqvJaFPJmaTY40,4524
-django_cfg/modules/django_client/system/templates/main_index.js.j2,sha256=rv5uYR4hjZRRCjWGqU_a7UsDbPx-CMu8itKdVBNsLHo,1827
-django_cfg/modules/django_client/system/templates/types.js.j2,sha256=hO6y0WwMOpkd3sMfmu9b2X7I2dyosodI8oW9Y8evhZo,744
 django_cfg/modules/django_currency/README.md,sha256=4R7KtF-rhR6yRg5jbsXwOVXMZNGEpOyW4N3WGN89W7A,4670
 django_cfg/modules/django_currency/__init__.py,sha256=Vm9-KPM7HqK0SM35YHjh2ciJoTYkDz3PR2bod6B2Alg,2490
 django_cfg/modules/django_currency/clients/__init__.py,sha256=bgrd3kJIgY-D80AQfs45pq9QanOkHdLfz2yAKsRnCyY,235
@@ -1025,7 +1015,7 @@ django_cfg/static/admin/js/alpine/commands-section.js,sha256=8z2MQNwZF9Tx_2EK1AY
 django_cfg/static/admin/js/alpine/dashboard-tabs.js,sha256=ob8Q_I9lFLDv_hFERXgTyvqMDBspAGfzCxI_7slRur4,1354
 django_cfg/static/admin/js/alpine/system-metrics.js,sha256=m-Fg55K_vpHXToD46PXL9twl4OBF_V9MONvbSWbQqDw,440
 django_cfg/static/admin/js/alpine/toggle-section.js,sha256=T141NFmy0fRJyGGuuaCJRjJXwPam-xxtQNW1hi8BJbc,672
-django_cfg/static/frontend/admin.zip,sha256=pLsFyDXNjsrLStXYZBYw820gPayTk8fYGZAy8_6kVtM,7645824
+django_cfg/static/frontend/admin.zip,sha256=MMRlhWT3NGk3_OkD06pRpNI9dskRQshbGdKAeUQdLFQ,7645836
 django_cfg/static/js/api-loader.mjs,sha256=boGqqRGnFR-Mzo_RQOjhAzNvsb7QxZddSwMKROzkk9Q,5163
 django_cfg/static/js/api/base.mjs,sha256=KUxZHHdELAV8mNnACpwJRvaQhdJxp-n5LFEQ4oUZxBo,4707
 django_cfg/static/js/api/index.mjs,sha256=_-Q04jjHcgwi4CGfiaLyiOR6NW7Yu1HBhJWp2J1cjpc,2538
@@ -1060,9 +1050,9 @@ django_cfg/utils/version_check.py,sha256=WO51J2m2e-wVqWCRwbultEwu3q1lQasV67Mw2aa
 django_cfg/CHANGELOG.md,sha256=jtT3EprqEJkqSUh7IraP73vQ8PmKUMdRtznQsEnqDZk,2052
 django_cfg/CONTRIBUTING.md,sha256=DU2kyQ6PU0Z24ob7O_OqKWEYHcZmJDgzw-lQCmu6uBg,3041
 django_cfg/LICENSE,sha256=xHuytiUkSZCRG3N11nk1X6q1_EGQtv6aL5O9cqNRhKE,1071
-django_cfg/pyproject.toml,sha256=Ut3Yvuw83bf3FmZzYAJL24fp1zbblv_c2p61XF7318A,8614
-django_cfg-1.4.108.dist-info/METADATA,sha256=IOJxCR_vzoWD4SuFisznEMmiEkvpx-mg_ktcf-TB81U,23801
-django_cfg-1.4.108.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-django_cfg-1.4.108.dist-info/entry_points.txt,sha256=Ucmde4Z2wEzgb4AggxxZ0zaYDb9HpyE5blM3uJ0_VNg,56
-django_cfg-1.4.108.dist-info/licenses/LICENSE,sha256=xHuytiUkSZCRG3N11nk1X6q1_EGQtv6aL5O9cqNRhKE,1071
-django_cfg-1.4.108.dist-info/RECORD,,
+django_cfg/pyproject.toml,sha256=yWqSAdesaQe0xiDRPoQw25Opq0yhKyr1nZM-k058-E4,8614
+django_cfg-1.4.109.dist-info/METADATA,sha256=Xml6V2JxDfn4DHkJAC0BLkupFncQDqJsON9sROSJvms,23801
+django_cfg-1.4.109.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+django_cfg-1.4.109.dist-info/entry_points.txt,sha256=Ucmde4Z2wEzgb4AggxxZ0zaYDb9HpyE5blM3uJ0_VNg,56
+django_cfg-1.4.109.dist-info/licenses/LICENSE,sha256=xHuytiUkSZCRG3N11nk1X6q1_EGQtv6aL5O9cqNRhKE,1071
+django_cfg-1.4.109.dist-info/RECORD,,

django_cfg/modules/django_client/system/__init__.py

@@ -1,24 +0,0 @@
-"""
-MJS Client Generation System for django-cfg
-
-This module provides a modular system for generating JavaScript ES modules
-with JSDoc type annotations from OpenAPI schemas.
-
-Components:
-- base_generator: Base class with common utilities
-- schema_parser: OpenAPI schema parsing and type extraction
-- mjs_generator: Main generator for MJS clients
-- templates/: Jinja2 templates for code generation
-"""
-
-from .base_generator import BaseGenerator
-from .mjs_generator import MJSGenerator
-from .schema_parser import SchemaParser
-
-__all__ = [
-    'BaseGenerator',
-    'SchemaParser',
-    'MJSGenerator'
-]
-
-__version__ = '1.0.0'

django_cfg/modules/django_client/system/base_generator.py

@@ -1,123 +0,0 @@
-"""
-Base generator class for MJS clients.
-Handles schema loading and common utilities.
-"""
-
-import json
-from pathlib import Path
-from typing import Any, Dict
-
-import yaml
-from jinja2 import Environment, FileSystemLoader
-
-
-class BaseGenerator:
-    """Base class for API client generation."""
-
-    def __init__(self, schema_path: Path, output_dir: Path):
-        """Initialize the generator with schema and output directory."""
-        self.schema_path = schema_path
-        self.output_dir = output_dir
-        self.schema = self._load_schema()
-
-        # Set up Jinja2 environment
-        template_dir = Path(__file__).parent / 'templates'
-        self.jinja_env = Environment(
-            loader=FileSystemLoader(template_dir),
-            trim_blocks=True,
-            lstrip_blocks=True,
-            keep_trailing_newline=True
-        )
-
-    def _load_schema(self) -> Dict[str, Any]:
-        """Load OpenAPI schema from JSON/YAML file."""
-        with open(self.schema_path) as f:
-            if self.schema_path.suffix == '.yaml':
-                return yaml.safe_load(f)
-            else:
-                return json.load(f)
-
-    def to_camel_case(self, snake_str: str) -> str:
-        """Convert snake_case to camelCase."""
-        snake_str = snake_str.replace(' ', '_').replace('-', '_')
-        components = snake_str.split('_')
-        return components[0] + ''.join(x.title() for x in components[1:])
-
-    def to_pascal_case(self, snake_str: str) -> str:
-        """Convert snake_case to PascalCase."""
-        snake_str = snake_str.replace(' ', '_').replace('-', '_')
-        return ''.join(word.capitalize() for word in snake_str.split('_'))
-
-    def sanitize_identifier(self, name: str) -> str:
-        """Sanitize a name to be a valid JavaScript identifier."""
-        # Replace spaces and special chars with underscores
-        sanitized = name.replace(' ', '_').replace('-', '_').replace('.', '_')
-        # Remove any remaining invalid characters
-        import re
-        sanitized = re.sub(r'[^a-zA-Z0-9_]', '', sanitized)
-        # Ensure it doesn't start with a number
-        if sanitized and sanitized[0].isdigit():
-            sanitized = '_' + sanitized
-        return sanitized
-
-    def get_type_from_schema(self, schema: Dict[str, Any]) -> str:
-        """Extract JavaScript type from OpenAPI schema."""
-        if not schema:
-            return 'any'
-
-        # Handle references
-        if '$ref' in schema:
-            ref_name = schema['$ref'].split('/')[-1]
-            return ref_name
-
-        # Handle arrays
-        if schema.get('type') == 'array':
-            items_type = self.get_type_from_schema(schema.get('items', {}))
-            return f'{items_type}[]'
-
-        # Handle objects
-        if schema.get('type') == 'object':
-            # If it has properties, we could generate an interface
-            # For now, just return a generic object type
-            if 'properties' in schema:
-                return 'Object'
-            return 'any'
-
-        # Handle primitive types
-        type_mapping = {
-            'string': 'string',
-            'integer': 'number',
-            'number': 'number',
-            'boolean': 'boolean',
-            'null': 'null'
-        }
-
-        openapi_type = schema.get('type', 'any')
-        return type_mapping.get(openapi_type, 'any')
-
-    def extract_response_type(self, operation: Dict[str, Any]) -> str:
-        """Extract the response type from an operation."""
-        responses = operation.get('responses', {})
-
-        # Look for successful response (200, 201, etc.)
-        for status in ['200', '201', '202', '204']:
-            if status in responses:
-                response = responses[status]
-
-                # Handle 204 No Content
-                if status == '204':
-                    return 'void'
-
-                # Extract content type
-                content = response.get('content', {})
-                if 'application/json' in content:
-                    schema = content['application/json'].get('schema', {})
-                    return self.get_type_from_schema(schema)
-
-        # Default to any if we can't determine the type
-        return 'any'
-
-    def render_template(self, template_name: str, **context) -> str:
-        """Render a Jinja2 template with the given context."""
-        template = self.jinja_env.get_template(template_name)
-        return template.render(**context)

django_cfg/modules/django_client/system/generate_mjs_clients.py

@@ -1,176 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to generate lightweight MJS (ES Module) clients for django-cfg project.
-
-This script generates JavaScript ES modules with JSDoc type annotations
-organized by Django apps for use in Django HTML templates.
-
-Usage:
-    poetry run python src/django_cfg/modules/django_client/system/generate_mjs_clients.py
-    poetry run python src/django_cfg/modules/django_client/system/generate_mjs_clients.py --clean
-"""
-
-import argparse
-import os
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-# Add current directory to path for imports
-sys.path.insert(0, str(Path(__file__).parent))
-
-from mjs_generator import MJSGenerator
-
-
-def main():
-    """Main function to generate MJS clients."""
-
-    parser = argparse.ArgumentParser(
-        description='Generate MJS API clients with JSDoc types for django-cfg project'
-    )
-    parser.add_argument(
-        '--clean',
-        action='store_true',
-        help='Clean existing files before generation'
-    )
-    parser.add_argument(
-        '--schema',
-        type=str,
-        help='Path to OpenAPI schema file (YAML or JSON)'
-    )
-    parser.add_argument(
-        '--output',
-        type=str,
-        help='Output directory for generated clients'
-    )
-
-    args = parser.parse_args()
-
-    # Determine paths
-    script_dir = Path(__file__).parent
-    django_client_dir = script_dir.parent  # django_client module
-    modules_dir = django_client_dir.parent  # modules
-    django_cfg_dir = modules_dir.parent  # django_cfg
-    src_dir = django_cfg_dir.parent  # src
-    dev_dir = src_dir.parent  # django-cfg-dev
-    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:
-        mjs_output_dir = Path(args.output)
-    else:
-        mjs_output_dir = django_cfg_dir / "static" / "js" / "api"
-
-    # Schema location
-    if args.schema:
-        schema_path = Path(args.schema)
-    else:
-        schema_path = example_django_dir / "openapi" / "schemas" / "cfg.yaml"
-
-    print("🚀 Generating MJS API clients with JSDoc type annotations...")
-    print(f"📁 Schema: {schema_path}")
-    print(f"📁 Output: {mjs_output_dir}")
-
-    # Generate schema if it doesn't exist
-    if not schema_path.exists():
-        print("⚙️  Generating OpenAPI schema first...")
-        os.chdir(example_django_dir)
-
-        result = subprocess.run(
-            ["poetry", "run", "python", "manage.py", "generate_client", "--typescript", "--no-python"],
-            capture_output=True,
-            text=True
-        )
-
-        if result.returncode != 0 or not schema_path.exists():
-            print("❌ Error: Could not generate schema")
-            print(result.stderr)
-            sys.exit(1)
-
-    # Check for dependencies
-    try:
-        import yaml
-    except ImportError:
-        print("❌ PyYAML is required. Install with: pip install pyyaml")
-        sys.exit(1)
-
-    try:
-        import jinja2
-    except ImportError:
-        print("❌ Jinja2 is required. Install with: pip install jinja2")
-        sys.exit(1)
-
-    # Generate MJS clients
-    try:
-        generator = MJSGenerator(schema_path, mjs_output_dir)
-        file_count = generator.generate()
-
-        print("\n✅ MJS clients generated successfully!")
-        print(f"📊 Generated {file_count} files in {mjs_output_dir}")
-        print("📂 Structure: Organized by Django apps with JSDoc types")
-
-        # Clean up openapi directory if it was created
-        openapi_dir = example_django_dir / "openapi"
-        if openapi_dir.exists():
-            print(f"🧹 Cleaning up example project openapi directory: {openapi_dir}")
-            shutil.rmtree(openapi_dir)
-
-        print("\n📝 Usage examples in Django template:")
-        print("""
-    <!-- Import from app folder with type support -->
-    <script type="module">
-        // Your IDE will provide autocomplete and type hints!
-        import { tasksAPI } from '{% static "api/tasks/index.mjs" %}';
-
-        async function loadTaskStats() {
-            try {
-                // IDE knows the return type from JSDoc annotations
-                const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
-                console.log('Task Stats:', stats);
-            } catch (error) {
-                // APIError type is documented
-                console.error('Error:', error);
-            }
-        }
-
-        loadTaskStats();
-    </script>
-
-    <!-- Import multiple APIs from main index -->
-    <script type="module">
-        import { tasksAPI, paymentsAPI } from '{% static "api/index.mjs" %}';
-
-        // Both APIs have full JSDoc documentation
-        const tasks = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
-        const webhooks = await paymentsAPI.cfgPaymentsWebhooksHealthRetrieve();
-    </script>
-
-    <!-- Use with custom base URL -->
-    <script type="module">
-        import { TasksAPI } from '{% static "api/tasks/index.mjs" %}';
-
-        // Constructor is documented with JSDoc
-        const api = new TasksAPI('https://api.example.com');
-        const stats = await api.cfgTasksApiTasksStatsRetrieve();
-    </script>
-        """)
-
-        print("\n🎯 Benefits of JSDoc types:")
-        print("   • IDE autocomplete and IntelliSense")
-        print("   • Type checking in VS Code and other editors")
-        print("   • Inline documentation in your editor")
-        print("   • Works with TypeScript if needed")
-        print("   • No build step required!")
-
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        sys.exit(1)
-
-
-if __name__ == '__main__':
-    main()

django_cfg/modules/django_client/system/mjs_generator.py

@@ -1,219 +0,0 @@
-"""
-MJS (ES Module) client generator for Django CFG.
-Generates JavaScript modules with JSDoc type annotations.
-"""
-
-import shutil
-from pathlib import Path
-from typing import Any, Dict, List
-
-from base_generator import BaseGenerator
-from schema_parser import SchemaParser
-
-
-class MJSGenerator(BaseGenerator):
-    """Generate MJS API clients with JSDoc type annotations."""
-
-    def __init__(self, schema_path: Path, output_dir: Path):
-        """Initialize the MJS generator."""
-        super().__init__(schema_path, output_dir)
-        self.parser = SchemaParser(self.schema)
-
-    def generate(self) -> int:
-        """Generate all MJS client files organized by apps."""
-        # Clean and create output directory
-        if self.output_dir.exists():
-            shutil.rmtree(self.output_dir)
-        self.output_dir.mkdir(parents=True, exist_ok=True)
-
-        # Generate base client
-        self._generate_base_client()
-
-        # Generate type definitions
-        self._generate_types()
-
-        # Group operations by app
-        operations_by_app = self.parser.group_operations_by_app()
-
-        # Generate client for each app
-        generated_apps = []
-        for app_name, operations in sorted(operations_by_app.items()):
-            # Skip certain apps
-            if app_name in ['default', 'endpoints', 'health']:
-                continue
-
-            self._generate_app_client(app_name, operations)
-            generated_apps.append(app_name)
-
-        # Generate main index file
-        self._generate_main_index(generated_apps)
-
-        # Count generated files
-        file_count = len(generated_apps) * 2 + 3  # apps * (client + index) + base + types + main index
-        return file_count
-
-    def _generate_base_client(self):
-        """Generate the base API client class."""
-        content = self.render_template('base_client.js.j2')
-
-        base_file = self.output_dir / 'base.mjs'
-        base_file.write_text(content)
-        print(f"  ✅ Generated: {base_file}")
-
-    def _generate_types(self):
-        """Generate type definitions from schema components."""
-        # Extract all schema definitions
-        schemas = self.schema.get('components', {}).get('schemas', {})
-
-        # Convert schemas to JSDoc typedef format
-        typedefs = []
-        for schema_name, schema_def in schemas.items():
-            typedef = self._schema_to_typedef(schema_name, schema_def)
-            if typedef:
-                typedefs.append(typedef)
-
-        content = self.render_template('types.js.j2', typedefs=typedefs)
-
-        types_file = self.output_dir / 'types.mjs'
-        types_file.write_text(content)
-        print(f"  ✅ Generated: {types_file}")
-
-    def _schema_to_typedef(self, name: str, schema: Dict[str, Any]) -> Dict[str, Any]:
-        """Convert an OpenAPI schema to a JSDoc typedef."""
-        if schema.get('type') != 'object':
-            return None
-
-        properties = []
-        required_props = schema.get('required', [])
-
-        for prop_name, prop_schema in schema.get('properties', {}).items():
-            prop_type = self.parser.get_js_type(prop_schema)
-            is_required = prop_name in required_props
-
-            properties.append({
-                'name': prop_name,
-                'type': prop_type,
-                'required': is_required,
-                'description': prop_schema.get('description', '')
-            })
-
-        return {
-            'name': name,
-            'description': schema.get('description', ''),
-            'properties': properties
-        }
-
-    def _generate_app_client(self, app_name: str, operations: List[Dict]):
-        """Generate client files for a specific app."""
-        # Create app directory
-        app_dir = self.output_dir / app_name
-        app_dir.mkdir(parents=True, exist_ok=True)
-
-        # Prepare operations data
-        methods = []
-        for op in operations:
-            method_data = self._prepare_method_data(op)
-            if method_data:
-                methods.append(method_data)
-
-        # Generate client file
-        class_name = self.to_pascal_case(app_name) + 'API'
-        instance_name = self.to_camel_case(app_name) + 'API'
-
-        content = self.render_template(
-            'api_client.js.j2',
-            app_name=app_name,
-            class_name=class_name,
-            instance_name=instance_name,
-            methods=methods
-        )
-
-        client_file = app_dir / 'client.mjs'
-        client_file.write_text(content)
-        print(f"  ✅ Generated: {client_file}")
-
-        # Generate app index
-        index_content = self.render_template(
-            'app_index.js.j2',
-            app_name=app_name,
-            class_name=class_name,
-            instance_name=instance_name
-        )
-
-        index_file = app_dir / 'index.mjs'
-        index_file.write_text(index_content)
-        print(f"  ✅ Generated: {index_file}")
-
-    def _prepare_method_data(self, operation: Dict[str, Any]) -> Dict[str, Any]:
-        """Prepare method data for template rendering."""
-        operation_id = operation.get('operationId', '')
-        if not operation_id:
-            return None
-
-        method_name = self.parser.extract_method_name(operation_id)
-        method_name = self.to_camel_case(method_name)
-
-        # Extract parameters
-        path_params = []
-        query_params = []
-
-        for param in operation.get('parameters', []):
-            param_info = self.parser.extract_parameter_info(param)
-
-            if param_info['in'] == 'path':
-                path_params.append(param_info)
-            elif param_info['in'] == 'query':
-                query_params.append(param_info)
-
-        # Extract request body
-        request_body = self.parser.extract_request_body_info(
-            operation.get('requestBody')
-        )
-
-        # Extract response type
-        response_type = self.parser.get_response_type(
-            operation.get('responses', {})
-        )
-
-        # Build path with template literals
-        api_path = operation['path']
-        for param in path_params:
-            api_path = api_path.replace(
-                f"{{{param['name']}}}",
-                f"${{{param['name']}}}"
-            )
-
-        return {
-            'name': method_name,
-            'http_method': operation['method'].upper(),
-            'path': api_path,
-            'summary': operation.get('summary', ''),
-            'description': operation.get('description', ''),
-            'path_params': path_params,
-            'query_params': query_params,
-            'request_body': request_body,
-            'response_type': response_type
-        }
-
-    def _generate_main_index(self, apps: List[str]):
-        """Generate the main index file."""
-        # Prepare app data for template
-        app_imports = []
-        for app_name in sorted(apps):
-            class_name = self.to_pascal_case(app_name) + 'API'
-            instance_name = self.to_camel_case(app_name) + 'API'
-
-            app_imports.append({
-                'app_name': app_name,
-                'class_name': class_name,
-                'instance_name': instance_name
-            })
-
-        content = self.render_template(
-            'main_index.js.j2',
-            apps=app_imports
-        )
-
-        index_file = self.output_dir / 'index.mjs'
-        index_file.write_text(content)
-        print(f"  ✅ Generated: {index_file}")

django_cfg/modules/django_client/system/schema_parser.py

@@ -1,199 +0,0 @@
-"""
-OpenAPI schema parser for extracting operation and type information.
-"""
-
-import re
-from typing import Any, Dict, List, Optional
-
-
-class SchemaParser:
-    """Parse OpenAPI schema to extract operation and type information."""
-
-    def __init__(self, schema: Dict[str, Any]):
-        """Initialize with OpenAPI schema."""
-        self.schema = schema
-        self.components = schema.get('components', {})
-        self.schemas = self.components.get('schemas', {})
-
-    def extract_app_from_path(self, path: str) -> str:
-        """Extract app name from API path."""
-        # Pattern: /cfg/{app_name}/...
-        match = re.match(r'/cfg/([^/]+)/', path)
-        if match:
-            return match.group(1)
-        return 'core'  # Default for paths without clear app
-
-    def extract_method_name(self, operation_id: str) -> str:
-        """Extract clean method name from operation ID."""
-        # Remove common prefixes
-        for prefix in ['cfg__', 'api_', 'cfg_']:
-            if operation_id.startswith(prefix):
-                operation_id = operation_id[len(prefix):]
-
-        # Handle double underscores
-        operation_id = operation_id.replace('__', '_')
-
-        return operation_id
-
-    def group_operations_by_app(self) -> Dict[str, List[Dict]]:
-        """Group API operations by Django app based on path patterns."""
-        grouped = {}
-
-        for path, path_item in self.schema.get('paths', {}).items():
-            for method, operation in path_item.items():
-                if method in ['get', 'post', 'put', 'patch', 'delete']:
-                    # Extract app name from path
-                    app_name = self.extract_app_from_path(path)
-
-                    # Add operation info
-                    op_info = {
-                        'path': path,
-                        'method': method,
-                        'operationId': operation.get('operationId', ''),
-                        'summary': operation.get('summary', ''),
-                        'description': operation.get('description', ''),
-                        'parameters': operation.get('parameters', []),
-                        'requestBody': operation.get('requestBody'),
-                        'responses': operation.get('responses', {}),
-                        'tags': operation.get('tags', [])
-                    }
-
-                    if app_name not in grouped:
-                        grouped[app_name] = []
-                    grouped[app_name].append(op_info)
-
-        return grouped
-
-    def extract_parameter_info(self, parameter: Dict[str, Any]) -> Dict[str, Any]:
-        """Extract detailed parameter information."""
-        param_info = {
-            'name': parameter.get('name'),
-            'in': parameter.get('in'),
-            'required': parameter.get('required', False),
-            'description': parameter.get('description', ''),
-            'schema': parameter.get('schema', {})
-        }
-
-        # Extract type information
-        schema = parameter.get('schema', {})
-        param_info['type'] = self.get_js_type(schema)
-        param_info['format'] = schema.get('format')
-
-        return param_info
-
-    def extract_request_body_info(self, request_body: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """Extract request body information."""
-        if not request_body:
-            return None
-
-        content = request_body.get('content', {})
-        json_content = content.get('application/json', {})
-        schema = json_content.get('schema', {})
-
-        return {
-            'required': request_body.get('required', False),
-            'description': request_body.get('description', ''),
-            'schema': schema,
-            'type': self.get_js_type(schema)
-        }
-
-    def get_js_type(self, schema: Dict[str, Any]) -> str:
-        """Convert OpenAPI schema to JavaScript/TypeScript type."""
-        if not schema:
-            return 'any'
-
-        # Handle references
-        if '$ref' in schema:
-            ref_name = schema['$ref'].split('/')[-1]
-            return ref_name
-
-        # Handle arrays
-        if schema.get('type') == 'array':
-            items_type = self.get_js_type(schema.get('items', {}))
-            return f'{items_type}[]'
-
-        # Handle objects
-        if schema.get('type') == 'object':
-            # Check if it has specific properties
-            if 'properties' in schema:
-                # Could generate an interface here
-                return 'Object'
-            # Check for additionalProperties (dictionary-like)
-            if 'additionalProperties' in schema:
-                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'
-
-        # Handle enums
-        if 'enum' in schema:
-            # Create a union type from enum values
-            values = schema['enum']
-            if all(isinstance(v, str) for v in values):
-                return ' | '.join(f'"{v}"' for v in values)
-            return 'string'
-
-        # Handle primitive types
-        type_mapping = {
-            'string': 'string',
-            'integer': 'number',
-            'number': 'number',
-            'boolean': 'boolean',
-            'null': 'null'
-        }
-
-        openapi_type = schema.get('type', 'any')
-
-        # Handle special formats
-        format_type = schema.get('format')
-        if openapi_type == 'string' and format_type:
-            format_mapping = {
-                'date': 'string',  # Could be Date
-                'date-time': 'string',  # Could be Date
-                'uuid': 'string',
-                'email': 'string',
-                'uri': 'string',
-                'binary': 'Blob',
-                'byte': 'string'
-            }
-            return format_mapping.get(format_type, 'string')
-
-        return type_mapping.get(openapi_type, 'any')
-
-    def get_response_type(self, responses: Dict[str, Any]) -> str:
-        """Extract the response type from operation responses."""
-        # Look for successful response (200, 201, etc.)
-        for status in ['200', '201', '202']:
-            if status in responses:
-                response = responses[status]
-                content = response.get('content', {})
-
-                if 'application/json' in content:
-                    schema = content['application/json'].get('schema', {})
-                    return self.get_js_type(schema)
-
-        # Check for 204 No Content
-        if '204' in responses:
-            return 'void'
-
-        # Default to any
-        return 'any'
-
-    def resolve_ref(self, ref: str) -> Optional[Dict[str, Any]]:
-        """Resolve a $ref to its schema definition."""
-        if not ref.startswith('#/'):
-            return None
-
-        parts = ref[2:].split('/')
-        current = self.schema
-
-        for part in parts:
-            if isinstance(current, dict) and part in current:
-                current = current[part]
-            else:
-                return None
-
-        return current

django_cfg/modules/django_client/system/templates/api_client.js.j2

@@ -1,87 +0,0 @@
-import { BaseAPIClient } from '../base.mjs';
-
-/**
- * {{ app_name.replace('_', ' ').title() }} API Client
- * Auto-generated from OpenAPI schema
- * @module {{ app_name }}
- * @extends BaseAPIClient
- */
-export class {{ class_name }} extends BaseAPIClient {
-    /**
-     * Initialize {{ app_name }} API client
-     * @param {string} [baseURL] - Optional base URL
-     */
-    constructor(baseURL) {
-        super(baseURL);
-    }
-
-{% for method in methods %}
-    /**
-     * {{ method.summary or method.name }}
-{%- if method.description %}
-     * {{ method.description }}
-{%- endif %}
-{%- for param in method.path_params %}
-     * @param {{ '{' }}{{ param.type }}{{ '}' }} {{ param.name }}{% if param.description %} - {{ param.description }}{% endif %}
-{%- endfor %}
-{%- if method.request_body %}
-     * @param {{ '{' }}{{ method.request_body.type }}{{ '}' }} data - Request body{% if method.request_body.description %} - {{ method.request_body.description }}{% endif %}
-{%- endif %}
-{%- if method.query_params %}
-     * @param {{ '{Object}' }} [params={}] - Query parameters
-{%- for param in method.query_params %}
-     * @param {{ '{' }}{{ param.type }}{{ '}' }} [params.{{ param.name }}]{% if param.description %} - {{ param.description }}{% endif %}
-{%- endfor %}
-{%- endif %}
-     * @returns {{ '{Promise<' }}{{ method.response_type }}{{ '>}' }} {{ 'Response data' if method.response_type != 'void' else 'No content' }}
-     */
-    async {{ method.name }}(
-{%- set params = [] %}
-{%- for param in method.path_params %}
-    {%- set _ = params.append(param.name) %}
-{%- endfor %}
-{%- if method.request_body %}
-    {%- set _ = params.append('data') %}
-{%- endif %}
-{%- if method.query_params %}
-    {%- set _ = params.append('params = {}') %}
-{%- endif %}
-{{- params | join(', ') -}}
-) {
-        const path = `{{ method.path }}`;
-{%- if method.http_method == 'GET' %}
-    {%- if method.query_params %}
-        return this.get(path, params);
-    {%- else %}
-        return this.get(path);
-    {%- endif %}
-{%- elif method.http_method == 'POST' %}
-    {%- if method.request_body %}
-        return this.post(path, data);
-    {%- else %}
-        return this.post(path, {});
-    {%- endif %}
-{%- elif method.http_method == 'PUT' %}
-    {%- if method.request_body %}
-        return this.put(path, data);
-    {%- else %}
-        return this.put(path, {});
-    {%- endif %}
-{%- elif method.http_method == 'PATCH' %}
-    {%- if method.request_body %}
-        return this.patch(path, data);
-    {%- else %}
-        return this.patch(path, {});
-    {%- endif %}
-{%- elif method.http_method == 'DELETE' %}
-        return this.delete(path);
-{%- endif %}
-    }
-{% endfor %}
-}
-
-// Default instance for convenience
-export const {{ instance_name }} = new {{ class_name }}();
-
-// Default export
-export default {{ class_name }};

django_cfg/modules/django_client/system/templates/app_index.js.j2

@@ -1,13 +0,0 @@
-/**
- * {{ app_name.replace('_', ' ').title() }} API Module
- * Re-exports the API client for convenient importing
- * @module {{ app_name }}
- */
-
-import { {{ class_name }}, {{ instance_name }} } from './client.mjs';
-
-// Re-export the class and instance
-export { {{ class_name }}, {{ instance_name }} };
-
-// Default export is the instance for convenience
-export default {{ instance_name }};

django_cfg/modules/django_client/system/templates/base_client.js.j2

@@ -1,166 +0,0 @@
-/**
- * Base API Client for django-cfg
- * Lightweight ES Module with JSDoc type annotations
- * @module base
- */
-
-/**
- * Custom error class for API errors
- * @class APIError
- * @extends Error
- */
-class APIError extends Error {
-    /**
-     * @param {string} message - Error message
-     * @param {number} status - HTTP status code
-     * @param {any} data - Additional error data
-     */
-    constructor(message, status, data) {
-        super(message);
-        this.name = 'APIError';
-        this.status = status;
-        this.data = data;
-    }
-}
-
-/**
- * Get Django CSRF token from cookies
- * @returns {string} CSRF token value
- */
-function getCsrfToken() {
-    const cookie = document.cookie.split('; ')
-        .find(row => row.startsWith('csrftoken='));
-    return cookie ? cookie.split('=')[1] : '';
-}
-
-/**
- * @typedef {Object} RequestOptions
- * @property {string} [method='GET'] - HTTP method
- * @property {Object} [headers={}] - Request headers
- * @property {any} [body] - Request body
- * @property {string} [credentials='same-origin'] - Credentials mode
- */
-
-/**
- * Base API client class with built-in Django CSRF support
- * @class BaseAPIClient
- */
-export class BaseAPIClient {
-    /**
-     * Initialize the API client
-     * @param {string} [baseURL=''] - Base URL for API requests (defaults to current origin)
-     */
-    constructor(baseURL = '') {
-        this.baseURL = baseURL || window.location.origin;
-    }
-
-    /**
-     * Make an API request
-     * @param {string} path - API endpoint path
-     * @param {RequestOptions} [options={}] - Request options
-     * @returns {Promise<any>} Response data
-     * @throws {APIError} When request fails
-     */
-    async request(path, options = {}) {
-        const url = `${this.baseURL}${path}`;
-
-        // Default headers with CSRF token
-        const headers = {
-            'Content-Type': 'application/json',
-            'X-CSRFToken': getCsrfToken(),
-            ...options.headers
-        };
-
-        try {
-            const response = await fetch(url, {
-                ...options,
-                headers,
-                credentials: 'same-origin'
-            });
-
-            if (!response.ok) {
-                const error = await response.json().catch(() => ({}));
-                throw new APIError(
-                    error.detail || `HTTP ${response.status}`,
-                    response.status,
-                    error
-                );
-            }
-
-            // Handle empty responses
-            if (response.status === 204) {
-                return null;
-            }
-
-            return await response.json();
-        } catch (error) {
-            if (error instanceof APIError) {
-                throw error;
-            }
-            throw new APIError(error.message, 0, null);
-        }
-    }
-
-    /**
-     * Make a GET request
-     * @param {string} path - API endpoint path
-     * @param {Object} [params={}] - Query parameters
-     * @returns {Promise<any>} Response data
-     */
-    async get(path, params = {}) {
-        const queryString = new URLSearchParams(params).toString();
-        const fullPath = queryString ? `${path}?${queryString}` : path;
-        return this.request(fullPath, { method: 'GET' });
-    }
-
-    /**
-     * Make a POST request
-     * @param {string} path - API endpoint path
-     * @param {any} [data={}] - Request body data
-     * @returns {Promise<any>} Response data
-     */
-    async post(path, data = {}) {
-        return this.request(path, {
-            method: 'POST',
-            body: JSON.stringify(data)
-        });
-    }
-
-    /**
-     * Make a PUT request
-     * @param {string} path - API endpoint path
-     * @param {any} [data={}] - Request body data
-     * @returns {Promise<any>} Response data
-     */
-    async put(path, data = {}) {
-        return this.request(path, {
-            method: 'PUT',
-            body: JSON.stringify(data)
-        });
-    }
-
-    /**
-     * Make a PATCH request
-     * @param {string} path - API endpoint path
-     * @param {any} [data={}] - Request body data
-     * @returns {Promise<any>} Response data
-     */
-    async patch(path, data = {}) {
-        return this.request(path, {
-            method: 'PATCH',
-            body: JSON.stringify(data)
-        });
-    }
-
-    /**
-     * Make a DELETE request
-     * @param {string} path - API endpoint path
-     * @returns {Promise<any>} Response data
-     */
-    async delete(path) {
-        return this.request(path, { method: 'DELETE' });
-    }
-}
-
-// Export the error class as well
-export { APIError };

django_cfg/modules/django_client/system/templates/main_index.js.j2

@@ -1,80 +0,0 @@
-/**
- * Django CFG API Clients
- * Lightweight ES Modules with JSDoc type annotations
- * Organized by Django apps
- *
- * @module django-cfg-api
- *
- * @example
- * // Import specific app API
- * import { tasksAPI } from '/static/api/tasks/index.mjs';
- * const stats = await tasksAPI.cfgTasksApiTasksStatsRetrieve();
- *
- * @example
- * // Import multiple APIs from main index
- * import { tasksAPI, paymentsAPI } from '/static/api/index.mjs';
- *
- * @example
- * // Import with custom base URL
- * import { TasksAPI } from '/static/api/tasks/index.mjs';
- * const api = new TasksAPI('https://api.example.com');
- */
-
-import { BaseAPIClient } from './base.mjs';
-{% for app in apps %}
-import { {{ app.class_name }}, {{ app.instance_name }} } from './{{ app.app_name }}/index.mjs';
-{% endfor %}
-
-/**
- * Export all API classes for custom instantiation
- * @exports
- */
-export {
-    BaseAPIClient,
-{% for app in apps %}
-    {{ app.class_name }},
-{% endfor %}
-};
-
-/**
- * Export all default instances for convenience
- * These instances use the current origin as base URL
- * @exports
- */
-export {
-{% for app in apps %}
-    {{ app.instance_name }},
-{% endfor %}
-};
-
-/**
- * Grouped exports by functionality
- * Access APIs by app name: apis.tasks, apis.payments, etc.
- * @type {Object.<string, BaseAPIClient>}
- */
-export const apis = {
-{% for app in apps %}
-    {{ app.app_name }}: {{ app.instance_name }},
-{% endfor %}
-};
-
-/**
- * Helper function to get API by app name
- * @param {string} appName - Name of the Django app
- * @returns {BaseAPIClient|undefined} API instance for the app
- * @example
- * const tasksAPI = getAPI('tasks');
- */
-export function getAPI(appName) {
-    return apis[appName];
-}
-
-/**
- * List of all available apps
- * @type {string[]}
- */
-export const availableApps = [
-{% for app in apps %}
-    '{{ app.app_name }}',
-{% endfor %}
-];

django_cfg/modules/django_client/system/templates/types.js.j2

@@ -1,24 +0,0 @@
-/**
- * Type definitions for django-cfg API
- * Auto-generated from OpenAPI schema
- * @module types
- */
-
-// This file contains JSDoc type definitions generated from the OpenAPI schema
-// These types can be used for better IDE support and documentation
-
-{% for typedef in typedefs %}
-/**
- * @typedef {{ '{Object}' }} {{ typedef.name }}
-{%- if typedef.description %}
- * @description {{ typedef.description }}
-{%- endif %}
-{%- for prop in typedef.properties %}
- * @property {{ '{' }}{{ prop.type }}{{ '}' }} {% if not prop.required %}[{% endif %}{{ prop.name }}{% if not prop.required %}]{% endif %}{% if prop.description %} - {{ prop.description }}{% endif %}
-{%- endfor %}
- */
-
-{% endfor %}
-
-// Export empty object to make this a module
-export {};