django-cfg 1.4.48__py3-none-any.whl → 1.5.7__py3-none-any.whl

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

@@ -65,7 +65,9 @@ export class APIClient {
   }
 
   /**
-   * Get CSRF token from cookies.
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
    */
   getCsrfToken(): string | null {
     const name = 'csrftoken';
@@ -127,7 +129,9 @@ export class APIClient {
       headers?: Record<string, string>;
     }
   ): Promise<T> {
-    const url = new URL(path, this.baseUrl);
+    // Build URL - handle both absolute and relative paths
+    // When baseUrl is empty (static builds), path is used as-is (relative to current origin)
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
     const startTime = Date.now();
 
     // Build headers - start with custom headers from options
@@ -140,19 +144,24 @@ export class APIClient {
       headers['Content-Type'] = 'application/json';
     }
 
-    // Add CSRF token for non-GET requests
+{% if has_session_auth %}
+    // Add CSRF token for SessionAuthentication
     if (method !== 'GET') {
       const csrfToken = this.getCsrfToken();
       if (csrfToken) {
         headers['X-CSRFToken'] = csrfToken;
       }
     }
+{% else %}
+    // CSRF not needed - SessionAuthentication not enabled in DRF config
+    // Your API uses JWT/Token authentication (no CSRF required)
+{% endif %}
 
     // Log request
     if (this.logger) {
       this.logger.logRequest({
         method,
-        url: url.toString(),
+        url: url,
         headers,
         body: options?.formData || options?.body,
         timestamp: startTime,
@@ -163,7 +172,7 @@ export class APIClient {
       // Make request via HTTP adapter
       const response = await this.httpClient.request<T>({
         method,
-        url: url.toString(),
+        url: url,
         headers,
         params: options?.params,
         body: options?.body,
@@ -178,7 +187,7 @@ export class APIClient {
           response.status,
           response.statusText,
           response.data,
-          url.toString()
+          url
         );
 
         // Log error
@@ -186,7 +195,7 @@ export class APIClient {
           this.logger.logError(
             {
               method,
-              url: url.toString(),
+              url: url,
               headers,
               body: options?.formData || options?.body,
               timestamp: startTime,
@@ -208,7 +217,7 @@ export class APIClient {
         this.logger.logResponse(
           {
             method,
-            url: url.toString(),
+            url: url,
             headers,
             body: options?.formData || options?.body,
             timestamp: startTime,
@@ -234,15 +243,15 @@ export class APIClient {
 
       // Wrap other errors as NetworkError
       const networkError = error instanceof Error
-        ? new NetworkError(error.message, url.toString(), error)
-        : new NetworkError('Unknown error', url.toString());
+        ? new NetworkError(error.message, url, error)
+        : new NetworkError('Unknown error', url);
 
       // Log network error
       if (this.logger) {
         this.logger.logError(
           {
             method,
-            url: url.toString(),
+            url: url,
             headers,
             body: options?.formData || options?.body,
             timestamp: startTime,
@@ -351,7 +360,9 @@ export class APIClient {
       headers?: Record<string, string>;
     }
   ): Promise<T> {
-    const url = new URL(path, this.baseUrl);
+    // Build URL - handle both absolute and relative paths
+    // When baseUrl is empty (static builds), path is used as-is (relative to current origin)
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
 
     // Build headers - start with custom headers from options
     const headers: Record<string, string> = {
@@ -363,19 +374,24 @@ export class APIClient {
       headers['Content-Type'] = 'application/json';
     }
 
-    // Add CSRF token for non-GET requests
+{% if has_session_auth %}
+    // Add CSRF token for SessionAuthentication
     if (method !== 'GET') {
       const csrfToken = this.getCsrfToken();
       if (csrfToken) {
         headers['X-CSRFToken'] = csrfToken;
       }
     }
+{% else %}
+    // CSRF not needed - SessionAuthentication not enabled in DRF config
+    // Your API uses JWT/Token authentication (no CSRF required)
+{% endif %}
 
     try {
       // Make request via HTTP adapter
       const response = await this.httpClient.request<T>({
         method,
-        url: url.toString(),
+        url: url,
         headers,
         params: options?.params,
         body: options?.body,
@@ -388,7 +404,7 @@ export class APIClient {
           response.status,
           response.statusText,
           response.data,
-          url.toString()
+          url
         );
       }
 
@@ -401,8 +417,8 @@ export class APIClient {
 
       // Wrap other errors as NetworkError
       throw error instanceof Error
-        ? new NetworkError(error.message, url.toString(), error)
-        : new NetworkError('Unknown error', url.toString());
+        ? new NetworkError(error.message, url, error)
+        : new NetworkError('Unknown error', url);
     }
   }
 

django_cfg/modules/django_client/core/generator/typescript/templates/client/flat_client.ts.jinja

@@ -25,7 +25,9 @@ export class APIClient {
   }
 
   /**
-   * Get CSRF token from cookies.
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
    */
   private getCsrfToken(): string | null {
     const name = 'csrftoken';
@@ -38,7 +40,7 @@ export class APIClient {
   }
 
   /**
-   * Make HTTP request with Django CSRF and session handling.
+   * Make HTTP request with automatic CSRF handling.
    */
   private async request<T>(
     method: string,
@@ -59,13 +61,18 @@ export class APIClient {
       headers['Content-Type'] = 'application/json';
     }
 
-    // Add CSRF token for non-GET requests
+{% if has_session_auth %}
+    // Add CSRF token for SessionAuthentication
     if (method !== 'GET') {
       const csrfToken = this.getCsrfToken();
       if (csrfToken) {
         headers['X-CSRFToken'] = csrfToken;
       }
     }
+{% else %}
+    // CSRF not needed - SessionAuthentication not enabled in DRF config
+    // Your API uses JWT/Token authentication (no CSRF required)
+{% endif %}
 
     try {
       // Make request via HTTP adapter

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

@@ -36,7 +36,6 @@ import { {{ schema_name }}Schema, type {{ schema_name }} } from '../schemas/{{ s
 {% endif %}
 {% if has_client %}
 import { getAPIInstance } from '../../api-instance'
-import type { API } from '../../index'
 {% endif %}
 
 {% for fetcher in fetchers %}

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

@@ -8,7 +8,7 @@ export async function {{ func_name }}(
 {%- if func_params %}
   {{ func_params }},
 {%- endif %}
-  client?
+  client?: any
 ): Promise<{{ response_type }}> {
   const api = client || getAPIInstance()
 {% if api_call_params %}

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

@@ -147,10 +147,8 @@ export class API {
       loggerConfig: this.options?.loggerConfig,
     });
 
-    // Inject Authorization header if token exists
-    if (this._token) {
-      this._injectAuthHeader();
-    }
+    // Always inject auth header wrapper (reads token dynamically from storage)
+    this._injectAuthHeader();
 
     // Initialize sub-clients from APIClient
 {% for tag in tags %}
@@ -169,10 +167,8 @@ export class API {
       loggerConfig: this.options?.loggerConfig,
     });
 
-    // Inject Authorization header if token exists
-    if (this._token) {
-      this._injectAuthHeader();
-    }
+    // Always inject auth header wrapper (reads token dynamically from storage)
+    this._injectAuthHeader();
 
     // Reinitialize sub-clients
 {% for tag in tags %}
@@ -188,12 +184,13 @@ export class API {
       path: string,
       options?: { params?: Record<string, any>; body?: any; formData?: FormData; headers?: Record<string, string> }
     ): Promise<T> => {
-      // Merge Authorization header with existing headers
+      // Read token from storage dynamically (supports JWT injection after instantiation)
+      const token = this.getToken();
       const mergedOptions = {
         ...options,
         headers: {
           ...(options?.headers || {}),
-          ...(this._token ? { 'Authorization': `Bearer ${this._token}` } : {}),
+          ...(token ? { 'Authorization': `Bearer ${token}` } : {}),
         },
       };
 

django_cfg/modules/django_client/core/generator/typescript/templates/utils/http.ts.jinja

@@ -39,13 +39,18 @@ export class FetchAdapter implements HttpClientAdapter {
     const { method, url, headers, body, params, formData } = request;
 
     // Build URL with query params
-    const finalUrl = new URL(url);
+    let finalUrl = url;
     if (params) {
+      const searchParams = new URLSearchParams();
       Object.entries(params).forEach(([key, value]) => {
         if (value !== null && value !== undefined) {
-          finalUrl.searchParams.append(key, String(value));
+          searchParams.append(key, String(value));
         }
       });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes('?') ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
     }
 
     // Build headers
@@ -65,7 +70,7 @@ export class FetchAdapter implements HttpClientAdapter {
     }
 
     // Make request
-    const response = await fetch(finalUrl.toString(), {
+    const response = await fetch(finalUrl, {
       method,
       headers: finalHeaders,
       body: requestBody,

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

@@ -151,6 +151,20 @@ class DjangoGlobalMetadata(BaseModel):
         description="Django session cookie name (default: 'sessionid')",
     )
 
+    # ===== Computed Properties =====
+
+    @property
+    def has_session_auth(self) -> bool:
+        """
+        Check if SessionAuthentication is enabled in DRF defaults.
+
+        Returns True if any authentication class contains 'SessionAuthentication'.
+        """
+        return any(
+            'SessionAuthentication' in auth_class
+            for auth_class in self.default_authentication_classes
+        )
+
     # ===== Validation =====
 
     @field_validator("component_split_request")

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

@@ -268,7 +268,18 @@ 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'
         """
+        # 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"
+
+        # For object fields without defined properties (like JSONField), use Any
+        if self.type == "object" and not self.properties:
+            return "Any | None" if self.nullable else "Any"
+
         type_map = {
             "string": "str",
             "integer": "int",

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

@@ -124,10 +124,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 +158,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.
@@ -214,6 +244,47 @@ class BaseParser(ABC):
         if not self.spec.components or not self.spec.components.schemas:
             return {}
 
+        # Check for duplicate schema names with different casing
+        schema_names = list(self.spec.components.schemas.keys())
+        lowercase_map = {}
+        exact_duplicate_map = {}
+
+        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."
+                )
+            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]
+
+                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"
+                )
+
+            # Store with title for later comparison
+            schema = self.spec.components.schemas.get(name)
+            title = getattr(schema, 'title', name)
+            exact_duplicate_map[name] = title
+
         schemas = {}
         for name, schema_or_ref in self.spec.components.schemas.items():
             # Skip references for now
@@ -438,15 +509,26 @@ 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:
-            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
 

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