@djangocfg/monitor 2.1.322 → 2.1.327

package/src/_api/generated/cfg_monitor/client.ts

@@ -1,330 +0,0 @@
-import { Monitor } from "./monitor";
-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;
-  private tokenGetter: (() => string | null) | null = null;
-
-  // Sub-clients
-  public monitor: Monitor;
-
-  constructor(
-    baseUrl: string,
-    options?: {
-      httpClient?: HttpClientAdapter;
-      loggerConfig?: Partial<LoggerConfig>;
-      retryConfig?: RetryConfig;
-      tokenGetter?: () => string | null;
-    }
-  ) {
-    this.baseUrl = baseUrl.replace(/\/$/, '');
-    this.httpClient = options?.httpClient || new FetchAdapter();
-    this.tokenGetter = options?.tokenGetter || null;
-
-    // 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.monitor = new Monitor(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;
-  }
-
-  /**
-   * Get the base URL for building streaming/download URLs.
-   */
-  getBaseUrl(): string {
-    return this.baseUrl;
-  }
-
-  /**
-   * Get JWT token for URL authentication (used in streaming endpoints).
-   * Returns null if no token getter is configured or no token is available.
-   */
-  getToken(): string | null {
-    return this.tokenGetter ? this.tokenGetter() : 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;
-      binaryBody?: Blob | ArrayBuffer;
-      headers?: Record<string, string>;
-      responseType?: 'json' | 'text' | 'blob';
-    }
-  ): 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;
-      binaryBody?: Blob | ArrayBuffer;
-      headers?: Record<string, string>;
-      responseType?: 'json' | 'text' | 'blob';
-    }
-  ): 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/binaryBody (browser will set it with boundary)
-    if (!options?.formData && !options?.binaryBody && !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)
-
-    // Add Authorization header from tokenGetter (Bearer token / API key)
-    if (!headers['Authorization']) {
-      const token = this.getToken();
-      if (token) {
-        headers['Authorization'] = `Bearer ${token}`;
-      }
-    }
-
-    // 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,
-        binaryBody: options?.binaryBody,
-        responseType: options?.responseType,
-      });
-
-      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;
-      }
-
-      // Classify network error using PerformanceResourceTiming.
-      // Browser intentionally makes CORS errors indistinguishable from network failures
-      // (same TypeError: "Failed to fetch") for security reasons. We use PerformanceResourceTiming
-      // as the best available heuristic:
-      //   - Entry exists with responseStatus === 0 → request reached server, JS blocked → likely CORS
-      //   - No entry / entry missing → connection never established → server unavailable / DNS / offline
-      // All cases are dispatched as 'network-error' with a `possibly_cors` flag.
-      let possiblyCors = false;
-      if (error instanceof TypeError && typeof window !== 'undefined') {
-        try {
-          const isCrossOrigin = (() => {
-            try { return new URL(url).origin !== window.location.origin; } catch { return false; }
-          })();
-          if (isCrossOrigin) {
-            const entries = performance.getEntriesByName(url, 'resource');
-            if (entries.length > 0) {
-              const last = entries[entries.length - 1] as PerformanceResourceTiming;
-              possiblyCors = 'responseStatus' in last && (last as any).responseStatus === 0;
-            }
-          }
-        } catch { /* ignore — PerformanceResourceTiming not available */ }
-      }
-
-      if (this.logger) {
-        this.logger.error(`⚠️  Network Error: ${method} ${url}`);
-        this.logger.error(`  → ${error instanceof Error ? error.message : String(error)}`);
-        if (possiblyCors) {
-          this.logger.error(`  → Possibly blocked by CORS policy (configure CORS on the server)`);
-        }
-      }
-
-      // Dispatch network-error event with possibly_cors hint
-      if (typeof window !== 'undefined') {
-        try {
-          window.dispatchEvent(new CustomEvent('network-error', {
-            detail: {
-              url: url,
-              method: method,
-              error: error instanceof Error ? error.message : String(error),
-              possibly_cors: possiblyCors,
-              timestamp: new Date(),
-            },
-            bubbles: true,
-            cancelable: false,
-          }));
-        } catch { /* silently ignore — event dispatch must 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/_api/generated/cfg_monitor/enums.ts

@@ -1,34 +0,0 @@
-// @ts-nocheck
-// Auto-generated by DjangoCFG - see CLAUDE.md
-/**
- * * `JS_ERROR` - JS_ERROR
- * * `NETWORK_ERROR` - NETWORK_ERROR
- * * `ERROR` - ERROR
- * * `WARNING` - WARNING
- * * `PAGE_VIEW` - PAGE_VIEW
- * * `PERFORMANCE` - PERFORMANCE
- * * `CONSOLE` - CONSOLE
- */
-export enum FrontendEventIngestRequestEventType {
-  JS_ERROR = "JS_ERROR",
-  NETWORK_ERROR = "NETWORK_ERROR",
-  ERROR = "ERROR",
-  WARNING = "WARNING",
-  PAGE_VIEW = "PAGE_VIEW",
-  PERFORMANCE = "PERFORMANCE",
-  CONSOLE = "CONSOLE",
-}
-
-/**
- * * `error` - error
- * * `warning` - warning
- * * `info` - info
- * * `debug` - debug
- */
-export enum FrontendEventIngestRequestLevel {
-  ERROR = "error",
-  WARNING = "warning",
-  INFO = "info",
-  DEBUG = "debug",
-}
-

package/src/_api/generated/cfg_monitor/errors.ts

@@ -1,123 +0,0 @@
-// @ts-nocheck
-// 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 "error" field (common in custom DRF views)
-    if (details.error) {
-      return String(details.error);
-    }
-
-    // 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/_api/generated/cfg_monitor/http.ts

@@ -1,160 +0,0 @@
-// @ts-nocheck
-// 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;
-  /** Binary data for octet-stream uploads */
-  binaryBody?: Blob | ArrayBuffer;
-  /**
-   * Force a specific response parser. When set, overrides Content-Type sniffing.
-   * Generated for endpoints whose primary response is binary (file downloads).
-   */
-  responseType?: 'json' | 'text' | 'blob';
-}
-
-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, binaryBody, responseType } = 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 | Blob | ArrayBuffer | 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 (binaryBody) {
-      // Binary upload (application/octet-stream)
-      finalHeaders['Content-Type'] = 'application/octet-stream';
-      requestBody = binaryBody;
-    } 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. Explicit `responseType` (set by the generator for binary
-    // endpoints) wins over Content-Type sniffing — backends often serve CSV/JSON
-    // file downloads with `text/csv` or `application/json`, which would otherwise
-    // be parsed as string/object instead of the Blob the caller expects.
-    //
-    //   responseType set        → use it directly
-    //   application/json        → JSON
-    //   text/*                  → string
-    //   anything else           → Blob (file downloads, octet-stream, …)
-    let data: any = null;
-    const contentType = response.headers.get('content-type') ?? '';
-
-    if (response.status !== 204) {
-      if (responseType === 'blob') {
-        data = await response.blob();
-      } else if (responseType === 'text') {
-        data = await response.text();
-      } else if (responseType === 'json') {
-        data = await response.json();
-      } else if (contentType.includes('application/json')) {
-        data = await response.json();
-      } else if (contentType.startsWith('text/')) {
-        data = await response.text();
-      } else {
-        data = await response.blob();
-      }
-    }
-
-    // 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,
-    };
-  }
-}
-
-/**
- * FetchAdapter with keepalive:true.
- *
- * Use this adapter when you need requests to survive page unload
- * (visibilitychange / beforeunload) — the browser will complete the request
- * even after the page is navigated away. Typical use: monitor / analytics flush.
- *
- * @example
- * ```typescript
- * import { APIClient, KeepAliveFetchAdapter } from './client';
- * const client = new APIClient(baseUrl, { httpClient: new KeepAliveFetchAdapter() });
- * ```
- */
-export class KeepAliveFetchAdapter extends FetchAdapter {
-  async request<T = any>(request: HttpRequest): Promise<HttpResponse<T>> {
-    const origFetch = globalThis.fetch;
-    globalThis.fetch = (input: RequestInfo | URL, init?: RequestInit) =>
-      origFetch(input, { ...init, keepalive: true });
-    try {
-      return await super.request<T>(request);
-    } finally {
-      globalThis.fetch = origFetch;
-    }
-  }
-}