@djangocfg/monitor 2.1.216

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

@@ -0,0 +1,25 @@
+// @ts-nocheck
+import * as Models from "./models";
+
+
+/**
+ * API endpoints for Monitor.
+ */
+export class Monitor {
+  private client: any;
+
+  constructor(client: any) {
+    this.client = client;
+  }
+
+  /**
+   * Ingest browser events
+   * 
+   * Accepts a batch of up to 50 frontend events. No authentication required.
+   */
+  async ingestCreate(data: Models.IngestBatchRequest): Promise<any> {
+    const response = await this.client.request('POST', "/cfg/monitor/ingest/", { body: data });
+    return response;
+  }
+
+}

package/src/_api/generated/cfg_monitor/monitor/index.ts

@@ -0,0 +1,4 @@
+// @ts-nocheck
+// Auto-generated by DjangoCFG - see CLAUDE.md
+export * from "./client";
+export * as Models from "./models";

package/src/_api/generated/cfg_monitor/monitor/models.ts

@@ -0,0 +1,48 @@
+// @ts-nocheck
+// Auto-generated by DjangoCFG - see CLAUDE.md
+import * as Enums from "../enums";
+
+/**
+ * Wraps a list of events. Enforces max batch size.
+ * 
+ * Request model (no read-only fields).
+ */
+export interface IngestBatchRequest {
+  events: Array<FrontendEventIngestRequest>;
+}
+
+/**
+ * Validates a single event from the browser.
+ * 
+ * Request model (no read-only fields).
+ */
+export interface FrontendEventIngestRequest {
+  /** * `ERROR` - Error
+  * `WARNING` - Warning
+  * `INFO` - Info
+  * `PAGE_VIEW` - Page View
+  * `PERFORMANCE` - Performance
+  * `NETWORK_ERROR` - Network Error
+  * `JS_ERROR` - JS Error
+  * `CONSOLE` - Console */
+  event_type: Enums.FrontendEventIngestRequestEventType;
+  message: string;
+  /** * `error` - Error
+  * `warn` - Warning
+  * `info` - Info
+  * `debug` - Debug */
+  level?: Enums.FrontendEventIngestRequestLevel;
+  stack_trace?: string;
+  url?: string;
+  fingerprint?: string;
+  http_status?: number | null;
+  http_method?: string;
+  http_url?: string;
+  user_agent?: string;
+  session_id?: string | null;
+  browser_fingerprint?: string;
+  extra?: Record<string, any>;
+  project_name?: string;
+  environment?: string;
+}
+

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

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

package/src/_api/generated/cfg_monitor/schema.json

@@ -0,0 +1,184 @@
+{
+  "openapi": "3.1.0",
+  "info": {
+    "title": "Django CFG API",
+    "version": "1.0.0",
+    "description": "Complete API documentation for Django CFG Demo Project",
+    "x-django-metadata": {
+      "group": "cfg_monitor",
+      "apps": [
+        "django_cfg_monitor"
+      ],
+      "generator": "django-client",
+      "generator_version": "1.0.0"
+    }
+  },
+  "paths": {
+    "/cfg/monitor/ingest/": {
+      "post": {
+        "operationId": "cfg_monitor_ingest_create",
+        "description": "Accepts a batch of up to 50 frontend events. No authentication required.",
+        "summary": "Ingest browser events",
+        "tags": [
+          "monitor"
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/IngestBatchRequest"
+              }
+            },
+            "application/x-www-form-urlencoded": {
+              "schema": {
+                "$ref": "#/components/schemas/IngestBatchRequest"
+              }
+            },
+            "multipart/form-data": {
+              "schema": {
+                "$ref": "#/components/schemas/IngestBatchRequest"
+              }
+            }
+          },
+          "required": true
+        },
+        "security": [
+          {}
+        ],
+        "responses": {
+          "202": {
+            "description": "Accepted"
+          }
+        },
+        "x-async-capable": false
+      }
+    }
+  },
+  "components": {
+    "schemas": {
+      "FrontendEventIngestRequest": {
+        "type": "object",
+        "description": "Validates a single event from the browser.",
+        "properties": {
+          "event_type": {
+            "enum": [
+              "ERROR",
+              "WARNING",
+              "INFO",
+              "PAGE_VIEW",
+              "PERFORMANCE",
+              "NETWORK_ERROR",
+              "JS_ERROR",
+              "CONSOLE"
+            ],
+            "type": "string",
+            "description": "* `ERROR` - Error\n* `WARNING` - Warning\n* `INFO` - Info\n* `PAGE_VIEW` - Page View\n* `PERFORMANCE` - Performance\n* `NETWORK_ERROR` - Network Error\n* `JS_ERROR` - JS Error\n* `CONSOLE` - Console",
+            "x-spec-enum-id": "de9da4754700e7fc"
+          },
+          "message": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 5000
+          },
+          "level": {
+            "enum": [
+              "error",
+              "warn",
+              "info",
+              "debug"
+            ],
+            "type": "string",
+            "description": "* `error` - Error\n* `warn` - Warning\n* `info` - Info\n* `debug` - Debug",
+            "x-spec-enum-id": "bef029ce9fe8228d",
+            "default": "info"
+          },
+          "stack_trace": {
+            "type": "string",
+            "default": "",
+            "maxLength": 20000
+          },
+          "url": {
+            "type": "string",
+            "default": "",
+            "maxLength": 2000
+          },
+          "fingerprint": {
+            "type": "string",
+            "default": "",
+            "maxLength": 64
+          },
+          "http_status": {
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
+          "http_method": {
+            "type": "string",
+            "default": "",
+            "maxLength": 10
+          },
+          "http_url": {
+            "type": "string",
+            "default": "",
+            "maxLength": 2000
+          },
+          "user_agent": {
+            "type": "string",
+            "default": "",
+            "maxLength": 500
+          },
+          "session_id": {
+            "type": [
+              "string",
+              "null"
+            ],
+            "format": "uuid"
+          },
+          "browser_fingerprint": {
+            "type": "string",
+            "default": "",
+            "maxLength": 64
+          },
+          "extra": {},
+          "project_name": {
+            "type": "string",
+            "default": "",
+            "maxLength": 100
+          },
+          "environment": {
+            "type": "string",
+            "default": "",
+            "maxLength": 20
+          }
+        },
+        "required": [
+          "event_type",
+          "message"
+        ]
+      },
+      "IngestBatchRequest": {
+        "type": "object",
+        "description": "Wraps a list of events. Enforces max batch size.",
+        "properties": {
+          "events": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/FrontendEventIngestRequest"
+            },
+            "maxItems": 50,
+            "minItems": 1
+          }
+        },
+        "required": [
+          "events"
+        ]
+      }
+    }
+  },
+  "servers": [
+    {
+      "url": "http://localhost:8000"
+    }
+  ]
+}

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

@@ -0,0 +1,163 @@
+// @ts-nocheck
+// Auto-generated by DjangoCFG - see CLAUDE.md
+/**
+ * Storage adapters for cross-platform token storage.
+ *
+ * Supports:
+ * - LocalStorage (browser)
+ * - Cookies (SSR/browser)
+ * - Memory (Node.js/Electron/testing)
+ */
+
+import type { APILogger } from './logger';
+
+/**
+ * Storage adapter interface for cross-platform token storage.
+ */
+export interface StorageAdapter {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+}
+
+/**
+ * LocalStorage adapter with safe try-catch for browser environments.
+ * Works in modern browsers with localStorage support.
+ * 
+ * Note: This adapter uses window.localStorage and should only be used in browser/client environments.
+ * For server-side usage, use MemoryStorageAdapter or CookieStorageAdapter instead.
+ */
+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) {
+        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) {
+      this.logger?.error('LocalStorage.getItem failed:', error);
+    }
+    return null;
+  }
+
+  setItem(key: string, value: string): void {
+    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) {
+      this.logger?.error('LocalStorage.setItem failed:', error);
+    }
+  }
+
+  removeItem(key: string): void {
+    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) {
+      this.logger?.error('LocalStorage.removeItem failed:', error);
+    }
+  }
+}
+
+/**
+ * Cookie-based storage adapter for SSR and browser environments.
+ * 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') {
+        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) {
+        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) {
+      this.logger?.error('CookieStorage.getItem failed:', error);
+    }
+    return null;
+  }
+
+  setItem(key: string, value: string): void {
+    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) {
+      this.logger?.error('CookieStorage.setItem failed:', error);
+    }
+  }
+
+  removeItem(key: string): void {
+    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) {
+      this.logger?.error('CookieStorage.removeItem failed:', error);
+    }
+  }
+}
+
+/**
+ * In-memory storage adapter for Node.js, Electron, and testing environments.
+ * Data is stored in RAM and cleared when process exits.
+ */
+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 {
+    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`);
+  }
+}