@djangocfg/api 2.1.54 → 2.1.56

package/src/generated/cfg_totp/client.ts

@@ -0,0 +1,313 @@
+import { 2faManagement } from "./totp__2fa_management";
+import { 2faSetup } from "./totp__2fa_setup";
+import { 2faVerification } from "./totp__2fa_verification";
+import { BackupCodes } from "./totp__backup_codes";
+import { Totp } from "./totp";
+import { HttpClientAdapter, FetchAdapter } from "./http";
+import { APIError, NetworkError } from "./errors";
+import { APILogger, type LoggerConfig } from "./logger";
+import { withRetry, type RetryConfig } from "./retry";
+
+
+/**
+ * Async API client for Django CFG API.
+ *
+ * Usage:
+ * ```typescript
+ * const client = new APIClient('https://api.example.com');
+ * const users = await client.users.list();
+ * const post = await client.posts.create(newPost);
+ *
+ * // Custom HTTP adapter (e.g., Axios)
+ * const client = new APIClient('https://api.example.com', {
+ *   httpClient: new AxiosAdapter()
+ * });
+ * ```
+ */
+export class APIClient {
+  private baseUrl: string;
+  private httpClient: HttpClientAdapter;
+  private logger: APILogger | null = null;
+  private retryConfig: RetryConfig | null = null;
+
+  // Sub-clients
+  public 2fa_management: 2faManagement;
+  public 2fa_setup: 2faSetup;
+  public 2fa_verification: 2faVerification;
+  public backup_codes: BackupCodes;
+  public totp: Totp;
+
+  constructor(
+    baseUrl: string,
+    options?: {
+      httpClient?: HttpClientAdapter;
+      loggerConfig?: Partial<LoggerConfig>;
+      retryConfig?: RetryConfig;
+    }
+  ) {
+    this.baseUrl = baseUrl.replace(/\/$/, '');
+    this.httpClient = options?.httpClient || new FetchAdapter();
+
+    // Initialize logger if config provided
+    if (options?.loggerConfig !== undefined) {
+      this.logger = new APILogger(options.loggerConfig);
+    }
+
+    // Store retry configuration
+    if (options?.retryConfig !== undefined) {
+      this.retryConfig = options.retryConfig;
+    }
+
+    // Initialize sub-clients
+    this.2fa_management = new 2faManagement(this);
+    this.2fa_setup = new 2faSetup(this);
+    this.2fa_verification = new 2faVerification(this);
+    this.backup_codes = new BackupCodes(this);
+    this.totp = new Totp(this);
+  }
+
+  /**
+   * Get CSRF token from cookies (for SessionAuthentication).
+   *
+   * Returns null if cookie doesn't exist (JWT-only auth).
+   */
+  getCsrfToken(): string | null {
+    const name = 'csrftoken';
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop()?.split(';').shift() || null;
+    }
+    return null;
+  }
+
+  /**
+   * Make HTTP request with Django CSRF and session handling.
+   * Automatically retries on network errors and 5xx server errors.
+   */
+  async request<T>(
+    method: string,
+    path: string,
+    options?: {
+      params?: Record<string, any>;
+      body?: any;
+      formData?: FormData;
+      headers?: Record<string, string>;
+    }
+  ): Promise<T> {
+    // Wrap request in retry logic if configured
+    if (this.retryConfig) {
+      return withRetry(() => this._makeRequest<T>(method, path, options), {
+        ...this.retryConfig,
+        onFailedAttempt: (info) => {
+          // Log retry attempts
+          if (this.logger) {
+            this.logger.warn(
+              `Retry attempt ${info.attemptNumber}/${info.retriesLeft + info.attemptNumber} ` +
+              `for ${method} ${path}: ${info.error.message}`
+            );
+          }
+          // Call user's onFailedAttempt if provided
+          this.retryConfig?.onFailedAttempt?.(info);
+        },
+      });
+    }
+
+    // No retry configured, make request directly
+    return this._makeRequest<T>(method, path, options);
+  }
+
+  /**
+   * Internal request method (without retry wrapper).
+   * Used by request() method with optional retry logic.
+   */
+  private async _makeRequest<T>(
+    method: string,
+    path: string,
+    options?: {
+      params?: Record<string, any>;
+      body?: any;
+      formData?: FormData;
+      headers?: Record<string, string>;
+    }
+  ): Promise<T> {
+    // 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
+    const headers: Record<string, string> = {
+      ...(options?.headers || {})
+    };
+
+    // Don't set Content-Type for FormData (browser will set it with boundary)
+    if (!options?.formData && !headers['Content-Type']) {
+      headers['Content-Type'] = 'application/json';
+    }
+
+    // CSRF not needed - SessionAuthentication not enabled in DRF config
+    // Your API uses JWT/Token authentication (no CSRF required)
+
+    // Log request
+    if (this.logger) {
+      this.logger.logRequest({
+        method,
+        url: url,
+        headers,
+        body: options?.formData || options?.body,
+        timestamp: startTime,
+      });
+    }
+
+    try {
+      // Make request via HTTP adapter
+      const response = await this.httpClient.request<T>({
+        method,
+        url: url,
+        headers,
+        params: options?.params,
+        body: options?.body,
+        formData: options?.formData,
+      });
+
+      const duration = Date.now() - startTime;
+
+      // Check for HTTP errors
+      if (response.status >= 400) {
+        const error = new APIError(
+          response.status,
+          response.statusText,
+          response.data,
+          url
+        );
+
+        // Log error
+        if (this.logger) {
+          this.logger.logError(
+            {
+              method,
+              url: url,
+              headers,
+              body: options?.formData || options?.body,
+              timestamp: startTime,
+            },
+            {
+              message: error.message,
+              statusCode: response.status,
+              duration,
+              timestamp: Date.now(),
+            }
+          );
+        }
+
+        throw error;
+      }
+
+      // Log successful response
+      if (this.logger) {
+        this.logger.logResponse(
+          {
+            method,
+            url: url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime,
+          },
+          {
+            status: response.status,
+            statusText: response.statusText,
+            data: response.data,
+            duration,
+            timestamp: Date.now(),
+          }
+        );
+      }
+
+      return response.data as T;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+
+      // Re-throw APIError as-is
+      if (error instanceof APIError) {
+        throw error;
+      }
+
+      // Detect CORS errors and dispatch event
+      const isCORSError = error instanceof TypeError &&
+        (error.message.toLowerCase().includes('cors') ||
+         error.message.toLowerCase().includes('failed to fetch') ||
+         error.message.toLowerCase().includes('network request failed'));
+
+      // Log specific error type first
+      if (this.logger) {
+        if (isCORSError) {
+          this.logger.error(`🚫 CORS Error: ${method} ${url}`);
+          this.logger.error(`  → ${error instanceof Error ? error.message : String(error)}`);
+          this.logger.error(`  → Configure security_domains parameter on the server`);
+        } else {
+          this.logger.error(`⚠️  Network Error: ${method} ${url}`);
+          this.logger.error(`  → ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+
+      // Dispatch browser events
+      if (typeof window !== 'undefined') {
+        try {
+          if (isCORSError) {
+            // Dispatch CORS-specific error event
+            window.dispatchEvent(new CustomEvent('cors-error', {
+              detail: {
+                url: url,
+                method: method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: new Date(),
+              },
+              bubbles: true,
+              cancelable: false,
+            }));
+          } else {
+            // Dispatch generic network error event
+            window.dispatchEvent(new CustomEvent('network-error', {
+              detail: {
+                url: url,
+                method: method,
+                error: error instanceof Error ? error.message : String(error),
+                timestamp: new Date(),
+              },
+              bubbles: true,
+              cancelable: false,
+            }));
+          }
+        } catch (eventError) {
+          // Silently fail - event dispatch should never crash the app
+        }
+      }
+
+      // Wrap other errors as NetworkError
+      const networkError = error instanceof Error
+        ? new NetworkError(error.message, url, error)
+        : new NetworkError('Unknown error', url);
+
+      // Detailed logging via logger.logError
+      if (this.logger) {
+        this.logger.logError(
+          {
+            method,
+            url: url,
+            headers,
+            body: options?.formData || options?.body,
+            timestamp: startTime,
+          },
+          {
+            message: networkError.message,
+            duration,
+            timestamp: Date.now(),
+          }
+        );
+      }
+
+      throw networkError;
+    }
+  }
+}

package/src/generated/cfg_totp/enums.ts

@@ -0,0 +1,12 @@
+// Auto-generated by DjangoCFG - see CLAUDE.md
+/**
+ * * `pending` - Pending Confirmation
+ * * `active` - Active
+ * * `disabled` - Disabled
+ */
+export enum DeviceListStatus {
+  PENDING = "pending",
+  ACTIVE = "active",
+  DISABLED = "disabled",
+}
+

package/src/generated/cfg_totp/errors.ts

@@ -0,0 +1,117 @@
+// Auto-generated by DjangoCFG - see CLAUDE.md
+/**
+ * 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';
+  }
+}

package/src/generated/cfg_totp/http.ts

@@ -0,0 +1,104 @@
+// Auto-generated by DjangoCFG - see CLAUDE.md
+/**
+ * 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
+    let finalUrl = url;
+    if (params) {
+      const searchParams = new URLSearchParams();
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+          searchParams.append(key, String(value));
+        }
+      });
+      const queryString = searchParams.toString();
+      if (queryString) {
+        finalUrl = url.includes('?') ? `${url}&${queryString}` : `${url}?${queryString}`;
+      }
+    }
+
+    // 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, {
+      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,
+    };
+  }
+}