django-cfg 1.4.21__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/modules/django_client/management/commands/generate_client.py

@@ -7,8 +7,8 @@ Usage:
     python manage.py generate_client --interactive
 """
 
+
 from django.core.management.base import BaseCommand, CommandError
-from typing import List, Optional
 
 
 class Command(BaseCommand):
@@ -78,7 +78,7 @@ class Command(BaseCommand):
         """Handle command execution."""
         try:
             # Import here to avoid Django import errors
-            from django_cfg.modules.django_client.core import get_openapi_service, GroupManager
+            from django_cfg.modules.django_client.core import get_openapi_service
 
             # Get service
             service = get_openapi_service()
@@ -126,9 +126,10 @@ class Command(BaseCommand):
             self.stdout.write(f"    Apps: {len(group_config.apps)} pattern(s)")
 
             # Show matched apps
-            from django_cfg.modules.django_client.core import GroupManager
             from django.apps import apps
 
+            from django_cfg.modules.django_client.core import GroupManager
+
             installed_apps = [app.name for app in apps.get_app_configs()]
             manager = GroupManager(service.config, installed_apps, groups=service.get_groups())
             matched_apps = manager.get_group_apps(group_name)
@@ -151,14 +152,15 @@ class Command(BaseCommand):
             self.stdout.write(self.style.SUCCESS("✅ Configuration is valid!"))
 
             # Show statistics
-            from django_cfg.modules.django_client.core import GroupManager
             from django.apps import apps
 
+            from django_cfg.modules.django_client.core import GroupManager
+
             installed_apps = [app.name for app in apps.get_app_configs()]
             manager = GroupManager(service.config, installed_apps, groups=service.get_groups())
             stats = manager.get_statistics()
 
-            self.stdout.write(f"\nStatistics:")
+            self.stdout.write("\nStatistics:")
             self.stdout.write(f"  • Total groups: {stats['total_groups']}")
             self.stdout.write(f"  • Total apps in groups: {stats['total_apps_in_groups']}")
             self.stdout.write(f"  • Ungrouped apps: {stats['ungrouped_apps']}")
@@ -239,17 +241,18 @@ class Command(BaseCommand):
         # Generate clients
         self.stdout.write("\n" + "=" * 60)
 
+        import shutil
+
+        from django.apps import apps
+        from drf_spectacular.generators import SchemaGenerator
+
         from django_cfg.modules.django_client.core import (
+            ArchiveManager,
             GroupManager,
-            parse_openapi,
             PythonGenerator,
             TypeScriptGenerator,
-            ArchiveManager,
+            parse_openapi,
         )
-        from django.apps import apps
-        from drf_spectacular.generators import SchemaGenerator
-        from pathlib import Path
-        import shutil
 
         # Clean output folders before generation
         schemas_dir = service.config.get_schemas_dir()

django_cfg/modules/django_client/management/commands/validate_openapi.py

@@ -9,9 +9,10 @@ Usage:
     python manage.py validate_openapi --report html          # Generate HTML report
 """
 
-from django.core.management.base import BaseCommand, CommandError
 from pathlib import Path
-from typing import List, Optional
+from typing import List
+
+from django.core.management.base import BaseCommand, CommandError
 
 
 class Command(BaseCommand):
@@ -119,10 +120,8 @@ class Command(BaseCommand):
         try:
             # Import validation components
             from django_cfg.modules.django_client.core.validation import (
-                ValidationChecker,
-                SafeFixer,
                 IssueReporter,
-                SafetyManager,
+                ValidationChecker,
             )
 
             # List rules
@@ -225,7 +224,6 @@ class Command(BaseCommand):
 
     def _check_files(self, checker, workspace: Path, options) -> List:
         """Check files for issues."""
-        from django_cfg.modules.django_client.core.validation import Issue
 
         if options["file"]:
             # Check specific file

django_cfg/modules/django_client/spectacular/__init__.py

@@ -4,8 +4,8 @@ DRF Spectacular hooks and schema classes for django-cfg.
 Auto-fixes and enhancements for OpenAPI schema generation.
 """
 
-from .enum_naming import auto_fix_enum_names
 from .async_detection import mark_async_operations
+from .enum_naming import auto_fix_enum_names
 from .schema import PathBasedAutoSchema
 
 __all__ = ['auto_fix_enum_names', 'mark_async_operations', 'PathBasedAutoSchema']

django_cfg/modules/django_client/spectacular/async_detection.py

@@ -7,8 +7,9 @@ operations with x-async-capable extension for dual client generation.
 
 import inspect
 import logging
-from typing import Dict, Any, Optional
-from django.urls import resolve, Resolver404
+from typing import Any, Dict, Optional
+
+from django.urls import Resolver404, resolve
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_client/spectacular/enum_naming.py

@@ -8,8 +8,8 @@ Instead generates: "ProductStatusEnum", "OrderStatusEnum", "PostStatusEnum", etc
 """
 
 import logging
-from typing import Dict, Any, Optional
 import re
+from typing import Any, Dict
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_client/spectacular/schema.py

@@ -5,6 +5,7 @@ Automatically determines tags based on URL paths for better API organization.
 """
 
 import re
+
 from drf_spectacular.openapi import AutoSchema
 
 
@@ -22,7 +23,7 @@ class PathBasedAutoSchema(AutoSchema):
     
     The TypeScript generator will use these tags to create properly structured folders.
     """
-    
+
     def get_tags(self):
         """
         Override tag determination to use path-based logic.
@@ -30,11 +31,10 @@ class PathBasedAutoSchema(AutoSchema):
         Returns:
             List of tags for this operation
         """
-        import re
-        
+
         # Get the path
         path = self.path
-        
+
         # For cfg URLs (/cfg/app_name/...), extract app_name as tag
         # The TypeScript generator will add the group prefix (cfg_) automatically
         cfg_pattern = re.compile(r"^/cfg/([^/]+)/")
@@ -44,7 +44,7 @@ class PathBasedAutoSchema(AutoSchema):
             # Return just the app_name (e.g., "support", "accounts", "payments")
             # Generator will create: cfg__support, cfg__accounts, etc.
             return [app_name]
-        
+
         # For other URLs, use default behavior (usually based on view name)
         return super().get_tags()
 

django_cfg/modules/django_client/system/__init__.py

@@ -0,0 +1,24 @@
+"""
+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

@@ -0,0 +1,123 @@
+"""
+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

@@ -0,0 +1,174 @@
+#!/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
+    example_django_dir = dev_dir.parent / "django-cfg-example" / "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()