@djangocfg/ext-support 1.0.0

package/src/api/generated/ext_support/logger.ts

@@ -0,0 +1,259 @@
+/**
+ * API Logger with Consola
+ * Beautiful console logging for API requests and responses
+ *
+ * Installation:
+ *   npm install consola
+ */
+
+import { type ConsolaInstance, createConsola } from 'consola';
+
+/**
+ * Request log data
+ */
+export interface RequestLog {
+  method: string;
+  url: string;
+  headers?: Record<string, string>;
+  body?: any;
+  timestamp: number;
+}
+
+/**
+ * Response log data
+ */
+export interface ResponseLog {
+  status: number;
+  statusText: string;
+  data?: any;
+  duration: number;
+  timestamp: number;
+}
+
+/**
+ * Error log data
+ */
+export interface ErrorLog {
+  message: string;
+  statusCode?: number;
+  fieldErrors?: Record<string, string[]>;
+  duration: number;
+  timestamp: number;
+}
+
+/**
+ * Logger configuration
+ */
+export interface LoggerConfig {
+  /** Enable logging */
+  enabled: boolean;
+  /** Log requests */
+  logRequests: boolean;
+  /** Log responses */
+  logResponses: boolean;
+  /** Log errors */
+  logErrors: boolean;
+  /** Log request/response bodies */
+  logBodies: boolean;
+  /** Log headers (excluding sensitive ones) */
+  logHeaders: boolean;
+  /** Custom consola instance */
+  consola?: ConsolaInstance;
+}
+
+/**
+ * Default logger configuration
+ */
+const DEFAULT_CONFIG: LoggerConfig = {
+  enabled: process.env.NODE_ENV !== 'production',
+  logRequests: true,
+  logResponses: true,
+  logErrors: true,
+  logBodies: true,
+  logHeaders: false,
+};
+
+/**
+ * Sensitive header names to filter out
+ */
+const SENSITIVE_HEADERS = [
+  'authorization',
+  'cookie',
+  'set-cookie',
+  'x-api-key',
+  'x-csrf-token',
+];
+
+/**
+ * API Logger class
+ */
+export class APILogger {
+  private config: LoggerConfig;
+  private consola: ConsolaInstance;
+
+  constructor(config: Partial<LoggerConfig> = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.consola = config.consola || createConsola({
+      level: this.config.enabled ? 4 : 0,
+    });
+  }
+
+  /**
+   * Enable logging
+   */
+  enable(): void {
+    this.config.enabled = true;
+  }
+
+  /**
+   * Disable logging
+   */
+  disable(): void {
+    this.config.enabled = false;
+  }
+
+  /**
+   * Update configuration
+   */
+  setConfig(config: Partial<LoggerConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+
+  /**
+   * Filter sensitive headers
+   */
+  private filterHeaders(headers?: Record<string, string>): Record<string, string> {
+    if (!headers) return {};
+
+    const filtered: Record<string, string> = {};
+    Object.keys(headers).forEach((key) => {
+      const lowerKey = key.toLowerCase();
+      if (SENSITIVE_HEADERS.includes(lowerKey)) {
+        filtered[key] = '***';
+      } else {
+        filtered[key] = headers[key] || '';
+      }
+    });
+
+    return filtered;
+  }
+
+  /**
+   * Log request
+   */
+  logRequest(request: RequestLog): void {
+    if (!this.config.enabled || !this.config.logRequests) return;
+
+    const { method, url, headers, body } = request;
+
+    this.consola.start(`${method} ${url}`);
+
+    if (this.config.logHeaders && headers) {
+      this.consola.debug('Headers:', this.filterHeaders(headers));
+    }
+
+    if (this.config.logBodies && body) {
+      this.consola.debug('Body:', body);
+    }
+  }
+
+  /**
+   * Log response
+   */
+  logResponse(request: RequestLog, response: ResponseLog): void {
+    if (!this.config.enabled || !this.config.logResponses) return;
+
+    const { method, url } = request;
+    const { status, statusText, data, duration } = response;
+
+    const statusColor = status >= 500 ? 'red'
+      : status >= 400 ? 'yellow'
+      : status >= 300 ? 'cyan'
+      : 'green';
+
+    this.consola.success(
+      `${method} ${url} ${status} ${statusText} (${duration}ms)`
+    );
+
+    if (this.config.logBodies && data) {
+      this.consola.debug('Response:', data);
+    }
+  }
+
+  /**
+   * Log error
+   */
+  logError(request: RequestLog, error: ErrorLog): void {
+    if (!this.config.enabled || !this.config.logErrors) return;
+
+    const { method, url } = request;
+    const { message, statusCode, fieldErrors, duration } = error;
+
+    this.consola.error(
+      `${method} ${url} ${statusCode || 'Network'} Error (${duration}ms)`
+    );
+
+    this.consola.error('Message:', message);
+
+    if (fieldErrors && Object.keys(fieldErrors).length > 0) {
+      this.consola.error('Field Errors:');
+      Object.entries(fieldErrors).forEach(([field, errors]) => {
+        errors.forEach((err) => {
+          this.consola.error(`  • ${field}: ${err}`);
+        });
+      });
+    }
+  }
+
+  /**
+   * Log general info
+   */
+  info(message: string, ...args: any[]): void {
+    if (!this.config.enabled) return;
+    this.consola.info(message, ...args);
+  }
+
+  /**
+   * Log warning
+   */
+  warn(message: string, ...args: any[]): void {
+    if (!this.config.enabled) return;
+    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
+   */
+  debug(message: string, ...args: any[]): void {
+    if (!this.config.enabled) return;
+    this.consola.debug(message, ...args);
+  }
+
+  /**
+   * Log success
+   */
+  success(message: string, ...args: any[]): void {
+    if (!this.config.enabled) return;
+    this.consola.success(message, ...args);
+  }
+
+  /**
+   * Create a sub-logger with prefix
+   */
+  withTag(tag: string): ConsolaInstance {
+    return this.consola.withTag(tag);
+  }
+}
+
+/**
+ * Default logger instance
+ */
+export const defaultLogger = new APILogger();

package/src/api/generated/ext_support/retry.ts

@@ -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,
+    }
+  );
+}