django-cfg 1.4.11__py3-none-any.whl → 1.4.13__py3-none-any.whl

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

@@ -0,0 +1,30 @@
+/**
+ * Typed Fetchers - Universal API functions
+ *
+ * Auto-generated from OpenAPI specification.
+ * These functions work in any JavaScript environment.
+ *
+ * Features:
+ * - Runtime validation with Zod
+ * - Type-safe parameters and responses
+ * - Works with any data-fetching library (SWR, React Query, etc)
+ * - Server Component compatible
+ *
+ * Usage:
+ * ```typescript
+ * import * as fetchers from './fetchers'
+ *
+ * // Direct usage
+ * const user = await fetchers.getUser(1)
+ *
+ * // With SWR
+ * const { data } = useSWR('user-1', () => fetchers.getUser(1))
+ *
+ * // With React Query
+ * const { data } = useQuery(['user', 1], () => fetchers.getUser(1))
+ * ```
+ */
+
+{% for module_name in modules %}
+export * from './{{ module_name }}'
+{% endfor %}

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

@@ -19,10 +19,12 @@
  *   // ...
  * }
  *
- * // Custom storage (for Electron/Node.js)
- * import { MemoryStorageAdapter } from './storage';
+ * // Custom storage with logging (for Electron/Node.js)
+ * import { MemoryStorageAdapter, APILogger } from './storage';
+ * const logger = new APILogger({ enabled: true, logLevel: 'debug' });
  * const api = new API('https://api.example.com', {
- *   storage: new MemoryStorageAdapter()
+ *   storage: new MemoryStorageAdapter(logger),
+ *   loggerConfig: { enabled: true, logLevel: 'debug' }
  * });
  *
  * // Get OpenAPI schema
@@ -38,20 +40,65 @@ import {
   CookieStorageAdapter,
   MemoryStorageAdapter
 } from "./storage";
+import type { RetryConfig } from "./retry";
+import type { LoggerConfig } from "./logger";
+import { APILogger } from "./logger";
 {% for tag in tags %}
 export * as {{ tag.class_name }}Types from "./{{ tag.slug }}/models";
 {% endfor %}
 {% if has_enums %}
 export * as Enums from "./enums";
 {% endif %}
+{% if generate_zod_schemas %}
 
-// Re-export storage adapters for convenience
+// Re-export Zod schemas for runtime validation
+export * as Schemas from "./_utils/schemas";
+{% endif %}
+{% if generate_fetchers %}
+
+// Re-export typed fetchers for universal usage
+export * as Fetchers from "./_utils/fetchers";
+
+// Re-export API instance configuration functions
 export {
-  StorageAdapter,
-  LocalStorageAdapter,
-  CookieStorageAdapter,
-  MemoryStorageAdapter
-};
+  configureAPI,
+  getAPIInstance,
+  reconfigureAPI,
+  clearAPITokens,
+  resetAPI,
+  isAPIConfigured
+} from "./api-instance";
+{% endif %}
+{% if generate_swr_hooks %}
+
+// Re-export SWR hooks for React
+export * as Hooks from "./_utils/hooks";
+{% endif %}
+
+// 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 };
+
+// Re-export error classes for convenience
+export { APIError, NetworkError } from "./errors";
+
+// Re-export HTTP adapters for custom implementations
+export type { HttpClientAdapter, HttpRequest, HttpResponse } from "./http";
+export { FetchAdapter } from "./http";
+
+// Re-export logger types and classes
+export type { LoggerConfig, RequestLog, ResponseLog, ErrorLog } from "./logger";
+export { APILogger } from "./logger";
+
+// Re-export retry configuration and utilities
+export type { RetryConfig, FailedAttemptInfo } from "./retry";
+export { withRetry, shouldRetry, DEFAULT_RETRY_CONFIG } from "./retry";
 
 export const TOKEN_KEY = "auth_token";
 export const REFRESH_TOKEN_KEY = "refresh_token";
@@ -59,6 +106,10 @@ export const REFRESH_TOKEN_KEY = "refresh_token";
 export interface APIOptions {
   /** Custom storage adapter (defaults to LocalStorageAdapter) */
   storage?: StorageAdapter;
+  /** Retry configuration for failed requests */
+  retryConfig?: RetryConfig;
+  /** Logger configuration */
+  loggerConfig?: Partial<LoggerConfig>;
 }
 
 export class API {
@@ -67,6 +118,7 @@ export class API {
   private _token: string | null = null;
   private _refreshToken: string | null = null;
   private storage: StorageAdapter;
+  private options?: APIOptions;
 
   // Sub-clients
 {% for tag in tags %}
@@ -75,7 +127,14 @@ export class API {
 
   constructor(baseUrl: string, options?: APIOptions) {
     this.baseUrl = baseUrl;
-    this.storage = options?.storage || new LocalStorageAdapter();
+    this.options = options;
+
+    // Create logger if config provided
+    const logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : undefined;
+
+    // Initialize storage with logger
+    this.storage = options?.storage || new LocalStorageAdapter(logger);
+
     this._loadTokensFromStorage();
     this._initClients();
   }
@@ -86,7 +145,10 @@ export class API {
   }
 
   private _initClients(): void {
-    this._client = new APIClient(this.baseUrl);
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: (this as any).options?.retryConfig,
+      loggerConfig: (this as any).options?.loggerConfig,
+    });
 
     // Inject Authorization header if token exists
     if (this._token) {

django_cfg/modules/django_client/core/generator/typescript/templates/package.json.jinja

@@ -0,0 +1,52 @@
+{
+  "name": "{{ package_name }}",
+  "version": "{{ version }}",
+  "description": "{{ description }}",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest",
+    "lint": "eslint src/",
+    "format": "prettier --write src/"
+  },
+  "keywords": {{ keywords | tojson }},
+  {% if author %}"author": "{{ author }}",{% endif %}
+  "license": "{{ license }}",
+  {% if repository_url %}"repository": {
+    "type": "git",
+    "url": "{{ repository_url }}"
+  },{% endif %}
+  "dependencies": {
+    "p-retry": "^7.0.0",
+    "consola": "^3.4.2"{% if generate_zod_schemas %},
+    "zod": "^3.23.0"{% endif %}{% if generate_swr_hooks %},
+    "swr": "^2.2.0"{% endif %}
+  },{% if generate_swr_hooks %}
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },{% endif %}
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.0.0",
+    "eslint": "^9.0.0",
+    "prettier": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }{% if private %},
+  "private": true{% endif %}
+}

django_cfg/modules/django_client/core/generator/typescript/templates/schemas/index.ts.jinja

@@ -0,0 +1,21 @@
+/**
+ * Zod Schemas - Runtime validation and type inference
+ *
+ * Auto-generated from OpenAPI specification.
+ * Provides runtime validation for API requests and responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { UserSchema } from './schemas'
+ *
+ * // Validate data
+ * const user = UserSchema.parse(data)
+ *
+ * // Type inference
+ * type User = z.infer<typeof UserSchema>
+ * ```
+ */
+
+{% for schema_name in schema_names %}
+export * from './{{ schema_name }}.schema'
+{% endfor %}

django_cfg/modules/django_client/core/generator/typescript/templates/schemas/schema.ts.jinja

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for {{ schema_name }}
+ *
+ * This schema provides runtime validation and type inference.
+ * {% if description %}
+ * {{ description }}
+ * {% endif %}
+ */
+import { z } from 'zod'
+{% if has_enums %}
+import * as Enums from '../../enums'
+{% endif %}
+{% if has_refs %}
+{% for ref_name in refs %}
+import { {{ ref_name }}Schema } from './{{ ref_name }}.schema'
+{% endfor %}
+{% endif %}
+
+{{ schema_code }}
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type {{ schema_name }} = z.infer<typeof {{ schema_name }}Schema>

django_cfg/modules/django_client/core/generator/typescript/templates/tsconfig.json.jinja

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "lib": ["ES2022", "DOM"],
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

django_cfg/modules/django_client/core/generator/{templates/typescript → typescript/templates}/utils/errors.ts.jinja

@@ -85,7 +85,9 @@ export class APIError extends Error {
     const fieldErrors = this.fieldErrors;
     if (fieldErrors) {
       const firstField = Object.keys(fieldErrors)[0];
-      return `${firstField}: ${fieldErrors[firstField].join(', ')}`;
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(', ')}`;
+      }
     }
 
     return this.message;

django_cfg/modules/django_client/core/generator/{templates/typescript → typescript/templates}/utils/logger.ts.jinja

@@ -131,7 +131,7 @@ export class APILogger {
       if (SENSITIVE_HEADERS.includes(lowerKey)) {
         filtered[key] = '***';
       } else {
-        filtered[key] = headers[key];
+        filtered[key] = headers[key] || '';
       }
     });
 
@@ -221,6 +221,14 @@ export class APILogger {
     this.consola.warn(message, ...args);
   }
 
+  /**
+   * Log error
+   */
+  error(message: string, ...args: any[]): void {
+    if (!this.config.enabled) return;
+    this.consola.error(message, ...args);
+  }
+
   /**
    * Log debug
    */

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

@@ -0,0 +1,175 @@
+/**
+ * Retry Configuration and Utilities
+ *
+ * Provides automatic retry logic for failed HTTP requests using p-retry.
+ * Retries only on network errors and server errors (5xx), not client errors (4xx).
+ */
+
+import pRetry, { AbortError } from 'p-retry';
+import { APIError, NetworkError } from './errors';
+
+/**
+ * Information about a failed retry attempt.
+ */
+export interface FailedAttemptInfo {
+  /** The error that caused the failure */
+  error: Error;
+  /** The attempt number (1-indexed) */
+  attemptNumber: number;
+  /** Number of retries left */
+  retriesLeft: number;
+}
+
+/**
+ * Retry configuration options.
+ *
+ * Uses exponential backoff with jitter by default to avoid thundering herd.
+ */
+export interface RetryConfig {
+  /**
+   * Maximum number of retry attempts.
+   * @default 3
+   */
+  retries?: number;
+
+  /**
+   * Exponential backoff factor.
+   * @default 2
+   */
+  factor?: number;
+
+  /**
+   * Minimum wait time between retries (ms).
+   * @default 1000
+   */
+  minTimeout?: number;
+
+  /**
+   * Maximum wait time between retries (ms).
+   * @default 60000
+   */
+  maxTimeout?: number;
+
+  /**
+   * Add randomness to wait times (jitter).
+   * Helps avoid thundering herd problem.
+   * @default true
+   */
+  randomize?: boolean;
+
+  /**
+   * Callback called on each failed attempt.
+   */
+  onFailedAttempt?: (info: FailedAttemptInfo) => void;
+}
+
+/**
+ * Default retry configuration.
+ */
+export const DEFAULT_RETRY_CONFIG: Required<RetryConfig> = {
+  retries: 3,
+  factor: 2,
+  minTimeout: 1000,
+  maxTimeout: 60000,
+  randomize: true,
+  onFailedAttempt: () => {},
+};
+
+/**
+ * Determine if an error should trigger a retry.
+ *
+ * Retries on:
+ * - Network errors (connection refused, timeout, etc.)
+ * - Server errors (5xx status codes)
+ * - Rate limiting (429 status code)
+ *
+ * Does NOT retry on:
+ * - Client errors (4xx except 429)
+ * - Authentication errors (401, 403)
+ * - Not found (404)
+ *
+ * @param error - The error to check
+ * @returns true if should retry, false otherwise
+ */
+export function shouldRetry(error: any): boolean {
+  // Always retry network errors
+  if (error instanceof NetworkError) {
+    return true;
+  }
+
+  // For API errors, check status code
+  if (error instanceof APIError) {
+    const status = error.statusCode;
+
+    // Retry on 5xx server errors
+    if (status >= 500 && status < 600) {
+      return true;
+    }
+
+    // Retry on 429 (rate limit)
+    if (status === 429) {
+      return true;
+    }
+
+    // Do NOT retry on 4xx client errors
+    return false;
+  }
+
+  // Retry on unknown errors (might be network issues)
+  return true;
+}
+
+/**
+ * Wrap a function with retry logic.
+ *
+ * @param fn - Async function to retry
+ * @param config - Retry configuration
+ * @returns Result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   async () => fetch('https://api.example.com/users'),
+ *   { retries: 5, minTimeout: 2000 }
+ * );
+ * ```
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  config?: RetryConfig
+): Promise<T> {
+  const finalConfig = { ...DEFAULT_RETRY_CONFIG, ...config };
+
+  return pRetry(
+    async () => {
+      try {
+        return await fn();
+      } catch (error) {
+        // Check if we should retry this error
+        if (!shouldRetry(error)) {
+          // Abort retry immediately for non-retryable errors
+          throw new AbortError(error as Error);
+        }
+
+        // Re-throw error to trigger retry
+        throw error;
+      }
+    },
+    {
+      retries: finalConfig.retries,
+      factor: finalConfig.factor,
+      minTimeout: finalConfig.minTimeout,
+      maxTimeout: finalConfig.maxTimeout,
+      randomize: finalConfig.randomize,
+      onFailedAttempt: finalConfig.onFailedAttempt ? (error) => {
+        // Adapt p-retry's FailedAttemptError to our FailedAttemptInfo
+        const pRetryError = error as any;  // p-retry's internal type
+        finalConfig.onFailedAttempt!({
+          error: pRetryError as Error,
+          attemptNumber: pRetryError.attemptNumber,
+          retriesLeft: pRetryError.retriesLeft,
+        });
+      } : undefined,
+    }
+  );
+}

django_cfg/modules/django_client/core/generator/{templates/typescript → typescript/templates}/utils/storage.ts.jinja

@@ -7,6 +7,8 @@
  * - Memory (Node.js/Electron/testing)
  */
 
+import type { APILogger } from './logger';
+
 /**
  * Storage adapter interface for cross-platform token storage.
  */
@@ -21,13 +23,22 @@ export interface StorageAdapter {
  * Works in modern browsers with localStorage support.
  */
 export class LocalStorageAdapter implements StorageAdapter {
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
+
   getItem(key: string): string | null {
     try {
       if (typeof window !== 'undefined' && window.localStorage) {
-        return localStorage.getItem(key);
+        const value = localStorage.getItem(key);
+        this.logger?.debug(`LocalStorage.getItem("${key}"): ${value ? 'found' : 'not found'}`);
+        return value;
       }
+      this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
     } catch (error) {
-      console.warn('LocalStorage not available:', error);
+      this.logger?.error('LocalStorage.getItem failed:', error);
     }
     return null;
   }
@@ -36,9 +47,12 @@ export class LocalStorageAdapter implements StorageAdapter {
     try {
       if (typeof window !== 'undefined' && window.localStorage) {
         localStorage.setItem(key, value);
+        this.logger?.debug(`LocalStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
       }
     } catch (error) {
-      console.warn('LocalStorage not available:', error);
+      this.logger?.error('LocalStorage.setItem failed:', error);
     }
   }
 
@@ -46,9 +60,12 @@ export class LocalStorageAdapter implements StorageAdapter {
     try {
       if (typeof window !== 'undefined' && window.localStorage) {
         localStorage.removeItem(key);
+        this.logger?.debug(`LocalStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn('LocalStorage not available: window.localStorage is undefined');
       }
     } catch (error) {
-      console.warn('LocalStorage not available:', error);
+      this.logger?.error('LocalStorage.removeItem failed:', error);
     }
   }
 }
@@ -58,16 +75,28 @@ export class LocalStorageAdapter implements StorageAdapter {
  * Useful for Next.js, Nuxt.js, and other SSR frameworks.
  */
 export class CookieStorageAdapter implements StorageAdapter {
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
+
   getItem(key: string): string | null {
     try {
-      if (typeof document === 'undefined') return null;
+      if (typeof document === 'undefined') {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
+        return null;
+      }
       const value = `; ${document.cookie}`;
       const parts = value.split(`; ${key}=`);
       if (parts.length === 2) {
-        return parts.pop()?.split(';').shift() || null;
+        const result = parts.pop()?.split(';').shift() || null;
+        this.logger?.debug(`CookieStorage.getItem("${key}"): ${result ? 'found' : 'not found'}`);
+        return result;
       }
+      this.logger?.debug(`CookieStorage.getItem("${key}"): not found`);
     } catch (error) {
-      console.warn('Cookies not available:', error);
+      this.logger?.error('CookieStorage.getItem failed:', error);
     }
     return null;
   }
@@ -76,9 +105,12 @@ export class CookieStorageAdapter implements StorageAdapter {
     try {
       if (typeof document !== 'undefined') {
         document.cookie = `${key}=${value}; path=/; max-age=31536000`;
+        this.logger?.debug(`CookieStorage.setItem("${key}"): success`);
+      } else {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
       }
     } catch (error) {
-      console.warn('Cookies not available:', error);
+      this.logger?.error('CookieStorage.setItem failed:', error);
     }
   }
 
@@ -86,9 +118,12 @@ export class CookieStorageAdapter implements StorageAdapter {
     try {
       if (typeof document !== 'undefined') {
         document.cookie = `${key}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        this.logger?.debug(`CookieStorage.removeItem("${key}"): success`);
+      } else {
+        this.logger?.warn('Cookies not available: document is undefined (SSR context?)');
       }
     } catch (error) {
-      console.warn('Cookies not available:', error);
+      this.logger?.error('CookieStorage.removeItem failed:', error);
     }
   }
 }
@@ -99,16 +134,25 @@ export class CookieStorageAdapter implements StorageAdapter {
  */
 export class MemoryStorageAdapter implements StorageAdapter {
   private storage: Map<string, string> = new Map();
+  private logger?: APILogger;
+
+  constructor(logger?: APILogger) {
+    this.logger = logger;
+  }
 
   getItem(key: string): string | null {
-    return this.storage.get(key) || null;
+    const value = this.storage.get(key) || null;
+    this.logger?.debug(`MemoryStorage.getItem("${key}"): ${value ? 'found' : 'not found'}`);
+    return value;
   }
 
   setItem(key: string, value: string): void {
     this.storage.set(key, value);
+    this.logger?.debug(`MemoryStorage.setItem("${key}"): success`);
   }
 
   removeItem(key: string): void {
     this.storage.delete(key);
+    this.logger?.debug(`MemoryStorage.removeItem("${key}"): success`);
   }
 }

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

@@ -356,6 +356,7 @@ class Command(BaseCommand):
                         client_structure=service.config.client_structure,
                         openapi_schema=schema_dict,
                         tag_prefix=f"{group_name}_",
+                        generate_package_files=service.config.generate_package_files,
                     )
                     py_files = py_generator.generate()
 
@@ -377,6 +378,10 @@ class Command(BaseCommand):
                         client_structure=service.config.client_structure,
                         openapi_schema=schema_dict,
                         tag_prefix=f"{group_name}_",
+                        generate_package_files=service.config.generate_package_files,
+                        generate_zod_schemas=service.config.generate_zod_schemas,
+                        generate_fetchers=service.config.generate_fetchers,
+                        generate_swr_hooks=service.config.generate_swr_hooks,
                     )
                     ts_files = ts_generator.generate()
 

django_cfg/modules/django_client/pytest.ini

@@ -0,0 +1,30 @@
+[pytest]
+# Pytest configuration for django_client tests
+
+testpaths = tests
+
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
+
+# Markers
+markers =
+    unit: Unit tests (fast, isolated)
+    integration: Integration tests (slower, may require setup)
+    slow: Slow tests (can be skipped for quick runs)
+
+# Output options
+addopts =
+    -v
+    --strict-markers
+    --tb=short
+    --color=yes
+    
+# Coverage options (if pytest-cov installed)
+# addopts = --cov=django_cfg.modules.django_client --cov-report=html --cov-report=term
+
+# Asyncio configuration
+asyncio_mode = auto
+
+# Ignore patterns
+norecursedirs = .git .tox dist build *.egg __pycache__