django-cfg 1.4.46__py3-none-any.whl → 1.5.181__py3-none-any.whl

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(
@@ -191,6 +195,10 @@ class IRSchemaObject(BaseModel):
     )
     deprecated: bool = Field(False, description="Field is deprecated")
     example: Any | None = Field(None, description="Example value")
+    default: Any | None = Field(
+        None,
+        description="Default value (used to infer array vs object for JSONField)",
+    )
 
     # ===== Computed Properties =====
 
@@ -268,13 +276,59 @@ class IRSchemaObject(BaseModel):
             'int'
             >>> IRSchemaObject(name="x", type="string", nullable=True).python_type
             'str | None'
+            >>> IRSchemaObject(name="x", type="string", read_only=True).python_type
+            'Any'
+            >>> IRSchemaObject(name="x", type="object", default=[]).python_type
+            'list[Any]'
+            >>> # $ref to another schema
+            >>> IRSchemaObject(name="x", type="object", ref="User").python_type
+            'User'
+            >>> # Array with $ref items
+            >>> IRSchemaObject(
+            ...     name="photos",
+            ...     type="array",
+            ...     items=IRSchemaObject(name="Photo", type="object", ref="PhotoInputRequest")
+            ... ).python_type
+            'list[PhotoInputRequest]'
         """
+        # Handle $ref (e.g., User, PhotoInputRequest, etc.)
+        if self.ref:
+            base_type = self.ref
+            return f"{base_type} | None" if self.nullable else base_type
+
+        # For read-only string fields, use Any since they often return complex objects
+        # from SerializerMethodField in Django (e.g., dicts instead of strings)
+        if self.read_only and self.type == "string":
+            return "Any | None" if self.nullable else "Any"
+
+        # SMART DETECTION: JSONField(default=list) case
+        # When type=object but default=[], it's actually an array
+        if self.type == "object" and not self.properties:
+            # Check if default value is a list
+            if isinstance(self.default, list):
+                return "list[Any] | None" if self.nullable else "list[Any]"
+            # Otherwise treat as dict with any values
+            # SAFETY: Always use Any for values to handle DictField edge cases
+            return "dict[str, Any] | None" if self.nullable else "dict[str, Any]"
+
+        # Handle array type with proper item type resolution
+        if self.type == "array":
+            if self.items:
+                # If items is a $ref, use the ref name directly
+                if self.items.ref:
+                    item_type = self.items.ref
+                else:
+                    item_type = self.items.python_type
+                base_type = f"list[{item_type}]"
+            else:
+                base_type = "list[Any]"
+            return f"{base_type} | None" if self.nullable else base_type
+
         type_map = {
             "string": "str",
             "integer": "int",
             "number": "float",
             "boolean": "bool",
-            "array": f"list[{self.items.python_type if self.items else 'Any'}]",
             "object": "dict[str, Any]",
         }
 
@@ -311,8 +365,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":
@@ -325,6 +382,27 @@ 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:
+            # SMART DETECTION: Check if default=[] for JSONField(default=list)
+            if isinstance(self.default, list):
+                base_type = "Array<any>"
+            elif self.additional_properties.ref:
+                # Only trust $ref types (explicit nested serializers)
+                value_type = self.additional_properties.ref
+                base_type = f"Record<string, {value_type}>"
+            else:
+                # SAFETY: Always use 'any' for additionalProperties without $ref
+                # DictField generates additionalProperties: {type: string} which is too restrictive
+                # Real data often contains boolean, number, nested objects
+                base_type = "Record<string, any>"
+        # Handle plain object without properties
+        elif self.type == "object" and not self.properties:
+            # SMART DETECTION: JSONField(default=list) case
+            if isinstance(self.default, list):
+                base_type = "Array<any>"
+            else:
+                base_type = "Record<string, any>"
         else:
             type_map = {
                 "string": "string",
@@ -332,6 +410,7 @@ class IRSchemaObject(BaseModel):
                 "number": "number",
                 "boolean": "boolean",
                 "object": "Record<string, any>",
+                "any": "any",
             }
             base_type = type_map.get(self.type, "any")
 

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

@@ -51,6 +51,7 @@ class BaseParser(ABC):
         """
         self.spec = spec
         self._schema_cache: dict[str, IRSchemaObject] = {}
+        self._inline_schemas: dict[str, IRSchemaObject] = {}  # For inline request/response schemas
 
     # ===== Main Parse Method =====
 
@@ -62,8 +63,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()
@@ -71,9 +76,12 @@ class BaseParser(ABC):
         # Parse schemas
         schemas = self._parse_all_schemas()
 
-        # Parse operations
+        # Parse operations (may add inline schemas to self._inline_schemas)
         operations = self._parse_all_operations()
 
+        # Merge inline schemas into main schemas dict
+        schemas.update(self._inline_schemas)
+
         return IRContext(
             openapi_info=openapi_info,
             django_metadata=django_metadata,
@@ -124,10 +132,14 @@ class BaseParser(ABC):
         if has_patch is None:
             has_patch = self._detect_component_split_patch()
 
+        # Get DRF authentication classes
+        auth_classes = self._get_drf_authentication_classes()
+
         return DjangoGlobalMetadata(
             component_split_request=has_split if has_split is not None else False,
             component_split_patch=has_patch if has_patch is not None else False,
             oas_version=self.spec.normalized_version,
+            default_authentication_classes=auth_classes,
         )
 
     def _get_django_spectacular_setting(self, setting_name: str) -> bool | None:
@@ -154,6 +166,32 @@ class BaseParser(ABC):
             # Any other error
             return None
 
+    def _get_drf_authentication_classes(self) -> list[str]:
+        """
+        Get DRF default authentication classes from Django settings.
+
+        Returns:
+            List of authentication class paths, or empty list if not available
+        """
+        try:
+            from django.conf import settings
+            if not settings.configured:
+                return []
+
+            rest_framework = getattr(settings, 'REST_FRAMEWORK', {})
+            auth_classes = rest_framework.get('DEFAULT_AUTHENTICATION_CLASSES', [])
+
+            # Ensure it's a list
+            if isinstance(auth_classes, (list, tuple)):
+                return list(auth_classes)
+            return []
+        except ImportError:
+            # Django not available (standalone usage)
+            return []
+        except Exception:
+            # Any other error
+            return []
+
     def _detect_component_split_request(self) -> bool:
         """
         Detect if COMPONENT_SPLIT_REQUEST: True is used.
@@ -207,13 +245,134 @@ class BaseParser(ABC):
 
         return False
 
+    # ===== 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
+
+        if not self.spec.components or not self.spec.components.schemas:
+            return  # No schemas to validate
+
+        schema_names = list(self.spec.components.schemas.keys())
+        lowercase_map = {}
+        exact_duplicate_sources = {}
+
+        for name in schema_names:
+            lowercase = name.lower()
+
+            # Check case-insensitive duplicates
+            if lowercase in lowercase_map:
+                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"
+                )
+
+                # 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"Case-insensitive schema name conflict: '{existing_name}' vs '{name}'. "
+                    f"Cannot generate client with conflicting schema names."
+                )
+
+            lowercase_map[lowercase] = name
+
+            # Track schema sources for exact duplicate detection
+            schema = self.spec.components.schemas.get(name)
+            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."""
+        """
+        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
@@ -298,17 +457,49 @@ 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
+                )
+        elif schema.additionalProperties is True:
+            # additionalProperties: true - allow any values
+            additional_properties = IRSchemaObject(
+                name=f"{name}.additionalProperties",
+                type="any",
+            )
+
+        # Detect empty object {} (JSONField with no schema)
+        # If type will be "object" but no properties and no additionalProperties,
+        # treat as Record<string, any>
+        normalized_type = self._normalize_type(schema)
+        if (normalized_type == "object" and
+            not properties and
+            not additional_properties and
+            schema.additionalProperties is not False):
+            # Empty object {} - treat as Record<string, any>
+            additional_properties = IRSchemaObject(
+                name=f"{name}.additionalProperties",
+                type="any",
+            )
+
         # Create IR schema
         ir_schema = IRSchemaObject(
             name=name,
-            type=self._normalize_type(schema),
+            type=normalized_type,
             format=schema.format,
             description=schema.description,
             nullable=self._detect_nullable(schema),
             properties=properties,
             required=schema.required or [],
+            additional_properties=additional_properties,
             items=items,
-            enum=schema.enum,
+            enum=[v for v in schema.enum if v is not None] if schema.enum else None,
             enum_var_names=schema.x_enum_varnames,
             const=schema.const,
             is_request_model=is_request,
@@ -324,6 +515,7 @@ class BaseParser(ABC):
             read_only=schema.readOnly,
             write_only=schema.writeOnly,
             deprecated=schema.deprecated,
+            default=schema.default,  # SMART DETECTION: Pass default value for JSONField(default=list) detection
         )
 
         # Cache
@@ -438,16 +630,39 @@ class BaseParser(ABC):
         if schema.base_type:
             return schema.base_type
 
+        # Check anyOf: [{"type": "X"}, {"type": "null"}] pattern (Pydantic style)
+        # Extract the actual type from anyOf if it's a simple nullable pattern
+        if schema.anyOf and len(schema.anyOf) == 2:
+            for item in schema.anyOf:
+                if isinstance(item, SchemaObject) and item.base_type and item.base_type != 'null':
+                    # Found the actual type (not null)
+                    return item.base_type
+
         # Fallback: infer from other properties
         if schema.properties is not None:
             return "object"
         if schema.items is not None:
             return "array"
 
-        # Special case: JSONField from Django has no type but description mentions JSON
-        if schema.description and 'JSON' in schema.description:
+        # Special case: Empty object {} from Django JSONField(default=dict)
+        # When drf-spectacular sees JSONField with no explicit type, it generates {}
+        # This happens because Django models don't provide schema info for JSONField
+        if (not schema.base_type and
+            not schema.properties and
+            not schema.items and
+            not schema.anyOf and
+            not schema.oneOf and
+            not schema.allOf):
+            # Empty schema {} - treat as object (most likely JSONField)
             return "object"
 
+        # Special case: JSONField from Django has no type but description hints at dict/object
+        # Check for keywords like: JSON, configuration, settings, config, dict
+        if schema.description:
+            desc_lower = schema.description.lower()
+            if any(keyword in desc_lower for keyword in ['json', 'configuration', 'settings', 'config', 'dict']):
+                return "object"
+
         return "string"  # Default
 
     # ===== Operation Parsing =====
@@ -485,13 +700,14 @@ class BaseParser(ABC):
         # Parse request body
         request_body = None
         patch_request_body = None
+        operation_id = operation.operationId or f"{method.lower()}_{path.replace('/', '_').strip('_')}"
 
         if operation.requestBody:
             if isinstance(operation.requestBody, ReferenceObject):
                 # TODO: Resolve reference
                 pass
             else:
-                body = self._parse_request_body(operation.requestBody)
+                body = self._parse_request_body(operation.requestBody, operation_id)
                 if method == "PATCH":
                     patch_request_body = body
                 else:
@@ -559,8 +775,13 @@ class BaseParser(ABC):
             deprecated=param.deprecated,
         )
 
-    def _parse_request_body(self, body: RequestBodyObject) -> IRRequestBodyObject:
-        """Parse RequestBodyObject to IRRequestBodyObject."""
+    def _parse_request_body(self, body: RequestBodyObject, operation_id: str) -> IRRequestBodyObject:
+        """Parse RequestBodyObject to IRRequestBodyObject.
+
+        Args:
+            body: The request body object from OpenAPI spec
+            operation_id: The operation ID for generating unique inline schema names
+        """
         # Extract schema name from content
         schema_name = None
         content_type = "application/json"
@@ -572,9 +793,14 @@ class BaseParser(ABC):
                     if isinstance(media_type.schema_, ReferenceObject):
                         schema_name = media_type.schema_.ref_name
                     else:
-                        # Inline schema - use operation ID as name
-                        # TODO: Generate proper name
-                        schema_name = "InlineRequestBody"
+                        # Inline schema - create unique name from operation_id
+                        # Convert operation_id to PascalCase and add "Request" suffix
+                        schema_name = self._to_pascal_case(operation_id) + "Request"
+
+                        # Parse the inline schema and register it
+                        inline_schema = self._parse_schema(schema_name, media_type.schema_)
+                        inline_schema.is_request_model = True
+                        self._inline_schemas[schema_name] = inline_schema
                 break
 
         return IRRequestBodyObject(
@@ -584,6 +810,11 @@ class BaseParser(ABC):
             description=body.description,
         )
 
+    def _to_pascal_case(self, name: str) -> str:
+        """Convert snake_case or kebab-case to PascalCase."""
+        from ..generator.proto.naming import to_pascal_case
+        return to_pascal_case(name)
+
     def _parse_responses(
         self, responses: dict[str, ResponseObject | ReferenceObject]
     ) -> dict[int, IRResponseObject]:
@@ -604,12 +835,14 @@ class BaseParser(ABC):
                 # TODO: Resolve reference
                 continue
 
-            # Extract schema name from content
+            # Extract schema name and content type from content
             schema_name = None
             is_paginated = False
+            content_type = "application/json"
 
             if response_or_ref.content:
-                for media_type in response_or_ref.content.values():
+                for ct, media_type in response_or_ref.content.items():
+                    content_type = ct
                     if media_type.schema_:
                         if isinstance(media_type.schema_, ReferenceObject):
                             schema_name = media_type.schema_.ref_name
@@ -621,6 +854,7 @@ class BaseParser(ABC):
             ir_responses[status_code] = IRResponseObject(
                 status_code=status_code,
                 schema_name=schema_name,
+                content_type=content_type,
                 description=response_or_ref.description,
                 is_paginated=is_paginated,
             )

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

@@ -37,6 +37,7 @@ class OpenAPI30Parser(BaseParser):
 
         In OpenAPI 3.0.x, nullable is indicated by:
             nullable: true
+            anyOf: [{"type": "string"}, {"type": "null"}]  # Pydantic style
 
         Examples:
             >>> schema = SchemaObject(type='string', nullable=True)
@@ -53,4 +54,28 @@ class OpenAPI30Parser(BaseParser):
         Returns:
             True if nullable, False otherwise
         """
-        return schema.is_nullable_30
+        # Check standard nullable: true format
+        if schema.is_nullable_30:
+            return True
+
+        # Check anyOf: [{"type": "X"}, {"type": "null"}] format (Pydantic)
+        # or anyOf: [{"$ref": "..."}, {"type": "null"}] format
+        if schema.anyOf and len(schema.anyOf) == 2:
+            has_null = False
+            has_actual_type = False
+
+            for item in schema.anyOf:
+                if not isinstance(item, SchemaObject):
+                    continue
+
+                if item.base_type == 'null':
+                    has_null = True
+                elif item.base_type or item.ref:
+                    # Has actual type (either base_type or $ref)
+                    has_actual_type = True
+
+            # If one is null and another is actual type, it's nullable
+            if has_null and has_actual_type:
+                return True
+
+        return False

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

@@ -40,6 +40,7 @@ class OpenAPI31Parser(BaseParser):
         In OpenAPI 3.1.0, nullable is indicated by:
             type: ['string', 'null']
             type: ['integer', 'null']
+            anyOf: [{"type": "string"}, {"type": "null"}]  # Pydantic style
             etc.
 
         Examples:
@@ -61,4 +62,28 @@ class OpenAPI31Parser(BaseParser):
         Returns:
             True if nullable, False otherwise
         """
-        return schema.is_nullable_31
+        # Check standard type: ['string', 'null'] format
+        if schema.is_nullable_31:
+            return True
+
+        # Check anyOf: [{"type": "X"}, {"type": "null"}] format (Pydantic)
+        # or anyOf: [{"$ref": "..."}, {"type": "null"}] format
+        if schema.anyOf and len(schema.anyOf) == 2:
+            has_null = False
+            has_actual_type = False
+
+            for item in schema.anyOf:
+                if not isinstance(item, SchemaObject):
+                    continue
+
+                if item.base_type == 'null':
+                    has_null = True
+                elif item.base_type or item.ref:
+                    # Has actual type (either base_type or $ref)
+                    has_actual_type = True
+
+            # If one is null and another is actual type, it's nullable
+            if has_null and has_actual_type:
+                return True
+
+        return False

django_cfg/modules/django_client/core/validation/checker.py

@@ -3,10 +3,27 @@
 from pathlib import Path
 from typing import List, Optional
 
-from .rules import Issue, ValidationRule
+from .rules import DictFieldRule, Issue, ValidationRule
 from .rules.type_hints import TypeHintRule
 
 
+# Directories to exclude from scanning
+EXCLUDE_DIRS = {'.venv', 'venv', 'env', 'site-packages', 'node_modules', '__pycache__', '.git', '.validation_backups'}
+
+
+def should_skip_path(path: Path) -> bool:
+    """
+    Check if path should be skipped during scanning.
+
+    Args:
+        path: Path to check
+
+    Returns:
+        True if path should be skipped
+    """
+    return any(part in EXCLUDE_DIRS for part in path.parts)
+
+
 class ValidationChecker:
     """
     Checks code against all validation rules.
@@ -28,6 +45,7 @@ class ValidationChecker:
         if rules is None:
             # Default rules
             self.rules = [
+                DictFieldRule(),  # Check for DictField/ListField usage
                 TypeHintRule(),
                 # Future: ResponseSchemaRule(),
                 # Future: EnumConflictRule(),
@@ -81,6 +99,10 @@ class ValidationChecker:
             files = directory.glob(pattern)
 
         for file_path in files:
+            # Skip excluded directories (venv, node_modules, etc.)
+            if should_skip_path(file_path):
+                continue
+
             if file_path.is_file():
                 issues = self.check_file(file_path)
                 all_issues.extend(issues)

django_cfg/modules/django_client/core/validation/rules/__init__.py

@@ -1,11 +1,13 @@
 """Validation rules for OpenAPI schema quality."""
 
 from .base import Issue, Severity, ValidationRule
+from .dict_field import DictFieldRule
 from .type_hints import TypeHintRule
 
 __all__ = [
     'Issue',
     'Severity',
     'ValidationRule',
+    'DictFieldRule',
     'TypeHintRule',
 ]