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

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

@@ -0,0 +1,268 @@
+/**
+ * {{ api_title }} - API Client with JWT Management
+ *
+ * Usage:
+ * ```typescript
+ * import { API } from './api';
+ *
+ * const api = new API('https://api.example.com');
+ *
+ * // Set JWT token
+ * api.setToken('your-jwt-token', 'refresh-token');
+ *
+ * // Use API
+ * const posts = await api.posts.list();
+ * const user = await api.users.retrieve(1);
+ *
+ * // Check authentication
+ * if (api.isAuthenticated()) {
+ *   // ...
+ * }
+ *
+ * // 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(logger),
+ *   loggerConfig: { enabled: true, logLevel: 'debug' }
+ * });
+ *
+ * // Get OpenAPI schema
+ * const schema = api.getSchema();
+ * ```
+ */
+
+import { APIClient } from "./client";
+import { OPENAPI_SCHEMA } from "./schema";
+import {
+  StorageAdapter,
+  LocalStorageAdapter,
+  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 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 {
+  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";
+
+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 {
+  private baseUrl: string;
+  private _client!: APIClient;
+  private _token: string | null = null;
+  private _refreshToken: string | null = null;
+  private storage: StorageAdapter;
+  private options?: APIOptions;
+
+  // Sub-clients
+{% for tag in tags %}
+  public {{ tag.property }}!: APIClient['{{ tag.property }}'];
+{% endfor %}
+
+  constructor(baseUrl: string, options?: APIOptions) {
+    this.baseUrl = baseUrl;
+    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();
+  }
+
+  private _loadTokensFromStorage(): void {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+
+  private _initClients(): void {
+    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) {
+      this._injectAuthHeader();
+    }
+
+    // Proxy sub-clients
+{% for tag in tags %}
+    this.{{ tag.property }} = this._client.{{ tag.property }};
+{% endfor %}
+  }
+
+  private _injectAuthHeader(): void {
+    // Override request method to inject auth header
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async <T>(
+      method: string,
+      path: string,
+      options?: { params?: Record<string, any>; body?: any }
+    ): Promise<T> => {
+      const headers: Record<string, string> = {};
+
+      if (this._token) {
+        headers['Authorization'] = `Bearer ${this._token}`;
+      }
+
+      // Merge with existing options
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...(options as any)?.headers,
+          ...headers,
+        },
+      };
+
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+
+  /**
+   * Get current JWT token
+   */
+  getToken(): string | null {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken(): string | null {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token: string, refreshToken?: string): void {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+
+    // Reinitialize clients with new token
+    this._initClients();
+  }
+
+  /**
+   * Clear all tokens
+   */
+  clearTokens(): void {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+
+    // Reinitialize clients without token
+    this._initClients();
+  }
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated(): boolean {
+    return !!this.getToken();
+  }
+
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url: string): void {
+    this.baseUrl = url;
+    this._initClients();
+  }
+
+  /**
+   * Get current base URL
+   */
+  getBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  /**
+   * Get OpenAPI schema
+   * @returns Complete OpenAPI specification for this API
+   */
+  getSchema(): any {
+    return OPENAPI_SCHEMA;
+  }
+}
+
+export default API;

django_cfg/modules/django_client/core/generator/typescript/templates/models/app_models.ts.jinja

@@ -0,0 +1,8 @@
+{% if has_enums %}
+import * as Enums from "../enums";
+
+{% endif %}
+{% for schema in schemas %}
+{{ schema }}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/typescript/templates/models/enums.ts.jinja

@@ -0,0 +1,4 @@
+{% for enum in enums %}
+{{ enum }}
+
+{% endfor %}

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

@@ -0,0 +1,8 @@
+{% if has_enums %}
+import * as Enums from "./enums";
+
+{% endif %}
+{% for schema in schemas %}
+{{ schema }}
+
+{% endfor %}

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/typescript/templates/utils/errors.ts.jinja

@@ -0,0 +1,116 @@
+/**
+ * API Error Classes
+ *
+ * Typed error classes with Django REST Framework support.
+ */
+
+/**
+ * HTTP API Error with DRF field-specific validation errors.
+ *
+ * Usage:
+ * ```typescript
+ * try {
+ *   await api.users.create(userData);
+ * } catch (error) {
+ *   if (error instanceof APIError) {
+ *     if (error.isValidationError) {
+ *       console.log('Field errors:', error.fieldErrors);
+ *       // { "email": ["Email already exists"], "username": ["Required"] }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export class APIError extends Error {
+  constructor(
+    public statusCode: number,
+    public statusText: string,
+    public response: any,
+    public url: string,
+    message?: string
+  ) {
+    super(message || `HTTP ${statusCode}: ${statusText}`);
+    this.name = 'APIError';
+  }
+
+  /**
+   * Get error details from response.
+   * DRF typically returns: { "detail": "Error message" } or { "field": ["error1", "error2"] }
+   */
+  get details(): Record<string, any> | null {
+    if (typeof this.response === 'object' && this.response !== null) {
+      return this.response;
+    }
+    return null;
+  }
+
+  /**
+   * Get field-specific validation errors from DRF.
+   * Returns: { "field_name": ["error1", "error2"], ... }
+   */
+  get fieldErrors(): Record<string, string[]> | null {
+    const details = this.details;
+    if (!details) return null;
+
+    // DRF typically returns: { "field": ["error1", "error2"] }
+    const fieldErrors: Record<string, string[]> = {};
+    for (const [key, value] of Object.entries(details)) {
+      if (Array.isArray(value)) {
+        fieldErrors[key] = value;
+      }
+    }
+
+    return Object.keys(fieldErrors).length > 0 ? fieldErrors : null;
+  }
+
+  /**
+   * Get single error message from DRF.
+   * Checks for "detail", "message", or first field error.
+   */
+  get errorMessage(): string {
+    const details = this.details;
+    if (!details) return this.message;
+
+    // Check for "detail" field (common in DRF)
+    if (details.detail) {
+      return Array.isArray(details.detail) ? details.detail.join(', ') : String(details.detail);
+    }
+
+    // Check for "message" field
+    if (details.message) {
+      return String(details.message);
+    }
+
+    // Return first field error
+    const fieldErrors = this.fieldErrors;
+    if (fieldErrors) {
+      const firstField = Object.keys(fieldErrors)[0];
+      if (firstField) {
+        return `${firstField}: ${fieldErrors[firstField]?.join(', ')}`;
+      }
+    }
+
+    return this.message;
+  }
+
+  // Helper methods for common HTTP status codes
+  get isValidationError(): boolean { return this.statusCode === 400; }
+  get isAuthError(): boolean { return this.statusCode === 401; }
+  get isPermissionError(): boolean { return this.statusCode === 403; }
+  get isNotFoundError(): boolean { return this.statusCode === 404; }
+  get isServerError(): boolean { return this.statusCode >= 500 && this.statusCode < 600; }
+}
+
+/**
+ * Network Error (connection failed, timeout, etc.)
+ */
+export class NetworkError extends Error {
+  constructor(
+    message: string,
+    public url: string,
+    public originalError?: Error
+  ) {
+    super(message);
+    this.name = 'NetworkError';
+  }
+}

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

@@ -0,0 +1,98 @@
+/**
+ * HTTP Client Adapter Pattern
+ *
+ * Allows switching between fetch/axios/httpx without changing generated code.
+ * Provides unified interface for making HTTP requests.
+ */
+
+export interface HttpRequest {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: any;
+  params?: Record<string, any>;
+  /** FormData for file uploads (multipart/form-data) */
+  formData?: FormData;
+}
+
+export interface HttpResponse<T = any> {
+  data: T;
+  status: number;
+  statusText: string;
+  headers: Record<string, string>;
+}
+
+/**
+ * HTTP Client Adapter Interface.
+ * Implement this to use custom HTTP clients (axios, httpx, etc.)
+ */
+export interface HttpClientAdapter {
+  request<T = any>(request: HttpRequest): Promise<HttpResponse<T>>;
+}
+
+/**
+ * Default Fetch API adapter.
+ * Uses native browser fetch() with proper error handling.
+ */
+export class FetchAdapter implements HttpClientAdapter {
+  async request<T = any>(request: HttpRequest): Promise<HttpResponse<T>> {
+    const { method, url, headers, body, params, formData } = request;
+
+    // Build URL with query params
+    const finalUrl = new URL(url);
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+          finalUrl.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    // Build headers
+    const finalHeaders: Record<string, string> = { ...headers };
+
+    // Determine body and content-type
+    let requestBody: string | FormData | undefined;
+
+    if (formData) {
+      // For multipart/form-data, let browser set Content-Type with boundary
+      requestBody = formData;
+      // Don't set Content-Type - browser will set it with boundary
+    } else if (body) {
+      // JSON request
+      finalHeaders['Content-Type'] = 'application/json';
+      requestBody = JSON.stringify(body);
+    }
+
+    // Make request
+    const response = await fetch(finalUrl.toString(), {
+      method,
+      headers: finalHeaders,
+      body: requestBody,
+      credentials: 'include',  // Include Django session cookies
+    });
+
+    // Parse response
+    let data: any = null;
+    const contentType = response.headers.get('content-type');
+
+    if (response.status !== 204 && contentType?.includes('application/json')) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+
+    // Convert Headers to plain object
+    const responseHeaders: Record<string, string> = {};
+    response.headers.forEach((value, key) => {
+      responseHeaders[key] = value;
+    });
+
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: responseHeaders,
+    };
+  }
+}