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

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/generator/typescript/templates/main_index.ts.jinja

@@ -33,7 +33,6 @@
  */
 
 import { APIClient } from "./client";
-import { OPENAPI_SCHEMA } from "./schema";
 import {
   StorageAdapter,
   LocalStorageAdapter,
@@ -82,9 +81,6 @@ export * as Hooks from "./_utils/hooks";
 // Re-export core client
 export { APIClient };
 
-// Re-export OpenAPI schema
-export { OPENAPI_SCHEMA };
-
 // Re-export storage adapters for convenience
 export type { StorageAdapter };
 export { LocalStorageAdapter, CookieStorageAdapter, MemoryStorageAdapter };
@@ -267,11 +263,19 @@ export class API {
   }
 
   /**
-   * Get OpenAPI schema
-   * @returns Complete OpenAPI specification for this API
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
    */
-  getSchema(): any {
-    return OPENAPI_SCHEMA;
+  getSchemaPath(): string {
+    return './schema.json';
   }
 }
 

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

@@ -62,8 +62,12 @@ class BaseParser(ABC):
             IRContext with all schemas and operations
 
         Raises:
-            ValueError: If COMPONENT_SPLIT_REQUEST is not detected
+            ValueError: If COMPONENT_SPLIT_REQUEST is not detected or schema name conflicts found
         """
+        # CRITICAL: Validate schema names BEFORE parsing
+        # This prevents generation from starting with invalid schemas
+        self._validate_schema_names()
+
         # Parse metadata
         openapi_info = self._parse_openapi_info()
         django_metadata = self._parse_django_metadata()
@@ -237,54 +241,134 @@ class BaseParser(ABC):
 
         return False
 
-    # ===== Schema Parsing =====
+    # ===== Schema Validation =====
+
+    def _validate_schema_names(self) -> None:
+        """
+        Validate schema names for conflicts BEFORE parsing.
+
+        This method checks for:
+        1. Case-insensitive duplicates (e.g., "User" and "user")
+        2. Exact duplicates (e.g., "GRPCServerInfo" from two different serializers)
+
+        Raises:
+            ValueError: If schema name conflicts are detected (hard exit with traceback)
+
+        Example conflicts:
+            - Case-insensitive: "Profile" and "profile" → filesystem conflict
+            - Exact duplicate: "HealthCheck" from multiple serializers → schema conflict
+        """
+        import traceback
+        import sys
 
-    def _parse_all_schemas(self) -> dict[str, IRSchemaObject]:
-        """Parse all schemas from components."""
         if not self.spec.components or not self.spec.components.schemas:
-            return {}
+            return  # No schemas to validate
 
-        # Check for duplicate schema names with different casing
         schema_names = list(self.spec.components.schemas.keys())
         lowercase_map = {}
-        exact_duplicate_map = {}
+        exact_duplicate_sources = {}
 
         for name in schema_names:
             lowercase = name.lower()
 
             # Check case-insensitive duplicates
             if lowercase in lowercase_map:
-                raise ValueError(
-                    f"Duplicate schema names with different casing detected:\n"
-                    f"  - {lowercase_map[lowercase]}\n"
-                    f"  - {name}\n"
-                    f"This causes conflicts in case-insensitive file systems.\n"
-                    f"Please rename one of the serializers in your Django code."
+                existing_name = lowercase_map[lowercase]
+                error_msg = (
+                    f"\n{'=' * 80}\n"
+                    f"❌ SCHEMA NAME CONFLICT DETECTED\n"
+                    f"{'=' * 80}\n\n"
+                    f"Conflict Type: Case-insensitive duplicate\n"
+                    f"Schema Names:\n"
+                    f"  1. '{existing_name}'\n"
+                    f"  2. '{name}'\n\n"
+                    f"Problem:\n"
+                    f"  These names differ only in casing and will cause conflicts on\n"
+                    f"  case-insensitive filesystems (macOS, Windows).\n\n"
+                    f"Solution:\n"
+                    f"  Rename one of the Django serializers to make them distinct.\n"
+                    f"  Example: {name}Serializer → {name}DetailSerializer\n\n"
+                    f"{'=' * 80}\n"
                 )
-            lowercase_map[lowercase] = name
 
-            # Check exact duplicates
-            if name in exact_duplicate_map:
-                # Get schema titles to show source serializer names
-                schema1 = self.spec.components.schemas.get(name)
-                title1 = getattr(schema1, 'title', 'Unknown')
-                title2 = exact_duplicate_map[name]
+                # Print full error with traceback
+                print(error_msg, file=sys.stderr)
+                print("\n🔍 Traceback (schema validation):", file=sys.stderr)
+                traceback.print_stack(file=sys.stderr)
 
+                # Hard exit - stop generation immediately
                 raise ValueError(
-                    f"Duplicate schema name detected: '{name}'\n"
-                    f"Multiple serializers are generating the same schema name:\n"
-                    f"  - {title1}\n"
-                    f"  - {title2}\n"
-                    f"This causes schema conflicts in the generated API client.\n"
-                    f"Please rename one of the serializers to make them unique.\n"
-                    f"Example: HealthCheckSerializer → GRPCHealthCheckSerializer"
+                    f"Case-insensitive schema name conflict: '{existing_name}' vs '{name}'. "
+                    f"Cannot generate client with conflicting schema names."
                 )
 
-            # Store with title for later comparison
+            lowercase_map[lowercase] = name
+
+            # Track schema sources for exact duplicate detection
             schema = self.spec.components.schemas.get(name)
-            title = getattr(schema, 'title', name)
-            exact_duplicate_map[name] = title
+            if schema and not isinstance(schema, ReferenceObject):
+                # Get source information from schema
+                title = getattr(schema, 'title', name)
+                description = getattr(schema, 'description', '')
+
+                # Create signature for duplicate detection
+                if name in exact_duplicate_sources:
+                    # Found exact duplicate!
+                    existing = exact_duplicate_sources[name]
+                    error_msg = (
+                        f"\n{'=' * 80}\n"
+                        f"❌ SCHEMA NAME CONFLICT DETECTED\n"
+                        f"{'=' * 80}\n\n"
+                        f"Conflict Type: Exact duplicate schema name\n"
+                        f"Schema Name: '{name}'\n\n"
+                        f"Sources:\n"
+                        f"  1. {existing['title']}\n"
+                        f"     Description: {existing['description'][:100]}\n"
+                        f"  2. {title}\n"
+                        f"     Description: {description[:100]}\n\n"
+                        f"Problem:\n"
+                        f"  Multiple serializers are generating the same schema name '{name}'.\n"
+                        f"  This causes schema conflicts in the generated API client and\n"
+                        f"  OpenAPI documentation.\n\n"
+                        f"Solution:\n"
+                        f"  Rename one of the serializers to make them unique.\n"
+                        f"  Examples:\n"
+                        f"    - HealthCheckSerializer → GRPCHealthCheckSerializer\n"
+                        f"    - ServerInfoSerializer → GRPCServerStatusSerializer\n\n"
+                        f"{'=' * 80}\n"
+                    )
+
+                    # Print full error with traceback
+                    print(error_msg, file=sys.stderr)
+                    print("\n🔍 Traceback (schema validation):", file=sys.stderr)
+                    traceback.print_stack(file=sys.stderr)
+
+                    # Hard exit - stop generation immediately
+                    raise ValueError(
+                        f"Duplicate schema name detected: '{name}'. "
+                        f"Multiple serializers are generating this schema. "
+                        f"Cannot generate client with conflicting schemas."
+                    )
+
+                # Store for duplicate detection
+                exact_duplicate_sources[name] = {
+                    'title': title,
+                    'description': description,
+                }
+
+    # ===== Schema Parsing =====
 
+    def _parse_all_schemas(self) -> dict[str, IRSchemaObject]:
+        """
+        Parse all schemas from components.
+
+        Note: Schema name validation is done in _validate_schema_names()
+        which is called BEFORE this method in parse().
+        """
+        if not self.spec.components or not self.spec.components.schemas:
+            return {}
+
+        # Parse schemas (validation already done in _validate_schema_names)
         schemas = {}
         for name, schema_or_ref in self.spec.components.schemas.items():
             # Skip references for now
@@ -369,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,
@@ -378,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/modules/django_client/management/commands/generate_client.py

@@ -8,12 +8,15 @@ Usage:
 """
 
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 
+from django_cfg.management.utils import AdminCommand
 
-class Command(BaseCommand):
+
+class Command(AdminCommand):
     """Generate OpenAPI clients for configured application groups."""
 
+    command_name = 'generate_client'
     help = "Generate Python, TypeScript, and Go API clients from OpenAPI schemas"
 
     def add_arguments(self, parser):

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

@@ -12,12 +12,15 @@ Usage:
 from pathlib import Path
 from typing import List
 
-from django.core.management.base import BaseCommand, CommandError
+from django.core.management.base import CommandError
 
+from django_cfg.management.utils import AdminCommand
 
-class Command(BaseCommand):
+
+class Command(AdminCommand):
     """Validate and fix OpenAPI schema quality issues in DRF serializers."""
 
+    command_name = 'validate_openapi'
     help = "Validate and auto-fix OpenAPI schema quality issues"
 
     def add_arguments(self, parser):

django_cfg/modules/django_email/management/commands/test_email.py

@@ -5,22 +5,16 @@ Tests email sending functionality using django_cfg configuration.
 """
 
 from django.contrib.auth import get_user_model
-from django.core.management.base import BaseCommand
 
-from django_cfg.modules.django_logging import get_logger
+from django_cfg.management.utils import SafeCommand
 
 User = get_user_model()
-logger = get_logger('test_email')
 
 
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to test email functionality."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'test_email'
     help = "Test email sending functionality"
 
     def add_arguments(self, parser):
@@ -48,7 +42,7 @@ class Command(BaseCommand):
         subject = options["subject"]
         message = options["message"]
 
-        logger.info(f"Starting email test for {email}")
+        self.logger.info(f"Starting email test for {email}")
         self.stdout.write(f"🚀 Testing email service for {email}")
 
         # Create test user if not exists

django_cfg/modules/django_ngrok/management/commands/runserver_ngrok.py

@@ -12,8 +12,6 @@ from django.core.management.commands.runserver import Command as RunServerComman
 from django_cfg.modules.django_logging import get_logger
 from django_cfg.modules.django_ngrok import get_ngrok_service
 
-logger = get_logger('runserver_ngrok')
-
 
 class Command(RunServerCommand):
     """Enhanced runserver command with ngrok tunnel support."""
@@ -25,6 +23,11 @@ class Command(RunServerCommand):
 
     help = f'{RunServerCommand.help.rstrip(".")} with ngrok tunnel.'
 
+    def __init__(self, *args, **kwargs):
+        """Initialize with logger."""
+        super().__init__(*args, **kwargs)
+        self.logger = get_logger('runserver_ngrok')
+
     def add_arguments(self, parser):
         super().add_arguments(parser)
         parser.add_argument(
@@ -76,14 +79,14 @@ class Command(RunServerCommand):
         ngrok_service = get_ngrok_service()
 
         self.stdout.write("🚇 Starting ngrok tunnel...")
-        logger.info(f"Starting ngrok tunnel for port {server_port}")
+        self.logger.info(f"Starting ngrok tunnel for port {server_port}")
 
         tunnel_url = ngrok_service.start_tunnel(server_port)
 
         if tunnel_url:
             # Wait for tunnel to be fully established
             self.stdout.write("⏳ Waiting for tunnel to be established...")
-            logger.info("Waiting for ngrok tunnel to be fully established")
+            self.logger.info("Waiting for ngrok tunnel to be fully established")
 
             max_retries = 10
             retry_count = 0
@@ -98,10 +101,10 @@ class Command(RunServerCommand):
                     current_url = ngrok_service.get_tunnel_url()
                     if current_url and current_url == tunnel_url:
                         tunnel_ready = True
-                        logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
+                        self.logger.info(f"Ngrok tunnel established successfully: {tunnel_url}")
                         break
                 except Exception as e:
-                    logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
+                    self.logger.warning(f"Tunnel check attempt {retry_count} failed: {e}")
 
                 self.stdout.write(f"⏳ Tunnel check {retry_count}/{max_retries}...")
 
@@ -116,16 +119,16 @@ class Command(RunServerCommand):
                 self.stdout.write(
                     self.style.SUCCESS(f"✅ Ngrok tunnel ready: {tunnel_url}")
                 )
-                logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
+                self.logger.info(f"Ngrok tunnel fully ready: {tunnel_url}")
             else:
                 self.stdout.write(
                     self.style.WARNING("⚠️ Ngrok tunnel started but may not be fully ready")
                 )
-                logger.warning("Ngrok tunnel started but readiness check failed")
+                self.logger.warning("Ngrok tunnel started but readiness check failed")
         else:
             error_msg = "Failed to start ngrok tunnel"
             self.stdout.write(self.style.ERROR(f"❌ {error_msg}"))
-            logger.error(error_msg)
+            self.logger.error(error_msg)
 
     def _set_ngrok_env_vars(self, tunnel_url: str):
         """Set environment variables with ngrok URL for easy access."""
@@ -145,10 +148,10 @@ class Command(RunServerCommand):
             os.environ['NGROK_API_URL'] = tunnel_url
 
             # Environment variables set - no need for verbose output
-            logger.info(f"Set ngrok environment variables: {tunnel_url}")
+            self.logger.info(f"Set ngrok environment variables: {tunnel_url}")
 
         except Exception as e:
-            logger.warning(f"Could not set ngrok environment variables: {e}")
+            self.logger.warning(f"Could not set ngrok environment variables: {e}")
 
     def _update_allowed_hosts(self, tunnel_url: str):
         """Update ALLOWED_HOSTS with ngrok domain."""
@@ -164,7 +167,7 @@ class Command(RunServerCommand):
             if hasattr(settings, 'ALLOWED_HOSTS'):
                 if ngrok_host not in settings.ALLOWED_HOSTS:
                     settings.ALLOWED_HOSTS.append(ngrok_host)
-                    logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
+                    self.logger.info(f"Added {ngrok_host} to ALLOWED_HOSTS")
 
         except Exception as e:
-            logger.warning(f"Could not update ALLOWED_HOSTS: {e}")
+            self.logger.warning(f"Could not update ALLOWED_HOSTS: {e}")

django_cfg/modules/django_telegram/management/commands/test_telegram.py

@@ -4,20 +4,13 @@ Test Telegram Command
 Tests Telegram notification functionality using django_cfg configuration.
 """
 
-from django.core.management.base import BaseCommand
+from django_cfg.management.utils import SafeCommand
 
-from django_cfg.modules.django_logging import get_logger
 
-logger = get_logger('test_telegram')
-
-class Command(BaseCommand):
+class Command(SafeCommand):
     """Command to test Telegram functionality."""
 
-    # Web execution metadata
-    web_executable = True
-    requires_input = False
-    is_destructive = False
-
+    command_name = 'test_telegram'
     help = "Test Telegram notification functionality"
 
     def add_arguments(self, parser):
@@ -29,7 +22,7 @@ class Command(BaseCommand):
         )
 
     def handle(self, *args, **options):
-        logger.info("Starting test_telegram command")
+        self.logger.info("Starting test_telegram command")
         message = options["message"]
 
         self.stdout.write("🚀 Testing Telegram notification service")