@djangocfg/ext-support 1.0.0

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

@@ -0,0 +1,301 @@
+import { ExtSupportSupport } from "./ext_support__support";
+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 ext_support_support: ExtSupportSupport;
+
+  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.ext_support_support = new ExtSupportSupport(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/api/generated/ext_support/enums.ts

@@ -0,0 +1,45 @@
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+export enum PatchedTicketRequestStatus {
+  OPEN = "open",
+  WAITING_FOR_USER = "waiting_for_user",
+  WAITING_FOR_ADMIN = "waiting_for_admin",
+  RESOLVED = "resolved",
+  CLOSED = "closed",
+}
+
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+export enum TicketStatus {
+  OPEN = "open",
+  WAITING_FOR_USER = "waiting_for_user",
+  WAITING_FOR_ADMIN = "waiting_for_admin",
+  RESOLVED = "resolved",
+  CLOSED = "closed",
+}
+
+/**
+ * * `open` - Open
+ * * `waiting_for_user` - Waiting for User
+ * * `waiting_for_admin` - Waiting for Admin
+ * * `resolved` - Resolved
+ * * `closed` - Closed
+ */
+export enum TicketRequestStatus {
+  OPEN = "open",
+  WAITING_FOR_USER = "waiting_for_user",
+  WAITING_FOR_ADMIN = "waiting_for_admin",
+  RESOLVED = "resolved",
+  CLOSED = "closed",
+}
+

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

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

package/src/api/generated/ext_support/ext_support__support/client.ts

@@ -0,0 +1,151 @@
+import * as Models from "./models";
+
+
+/**
+ * API endpoints for Support.
+ */
+export class ExtSupportSupport {
+  private client: any;
+
+  constructor(client: any) {
+    this.client = client;
+  }
+
+  async ticketsList(page?: number, page_size?: number): Promise<Models.PaginatedTicketList>;
+  async ticketsList(params?: { page?: number; page_size?: number }): Promise<Models.PaginatedTicketList>;
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsList(...args: any[]): Promise<Models.PaginatedTicketList> {
+    const isParamsObject = args.length === 1 && typeof args[0] === 'object' && args[0] !== null && !Array.isArray(args[0]);
+    
+    let params;
+    if (isParamsObject) {
+      params = args[0];
+    } else {
+      params = { page: args[0], page_size: args[1] };
+    }
+    const response = await this.client.request('GET', "/cfg/support/tickets/", { params });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsCreate(data: Models.TicketRequest): Promise<Models.Ticket> {
+    const response = await this.client.request('POST', "/cfg/support/tickets/", { body: data });
+    return response;
+  }
+
+  async ticketsMessagesList(ticket_uuid: string, page?: number, page_size?: number): Promise<Models.PaginatedMessageList>;
+  async ticketsMessagesList(ticket_uuid: string, params?: { page?: number; page_size?: number }): Promise<Models.PaginatedMessageList>;
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesList(...args: any[]): Promise<Models.PaginatedMessageList> {
+    const ticket_uuid = args[0];
+    const isParamsObject = args.length === 2 && typeof args[1] === 'object' && args[1] !== null && !Array.isArray(args[1]);
+    
+    let params;
+    if (isParamsObject) {
+      params = args[1];
+    } else {
+      params = { page: args[1], page_size: args[2] };
+    }
+    const response = await this.client.request('GET', `/cfg/support/tickets/${ticket_uuid}/messages/`, { params });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesCreate(ticket_uuid: string, data: Models.MessageCreateRequest): Promise<Models.MessageCreate> {
+    const response = await this.client.request('POST', `/cfg/support/tickets/${ticket_uuid}/messages/`, { body: data });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesRetrieve(ticket_uuid: string, uuid: string): Promise<Models.Message> {
+    const response = await this.client.request('GET', `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`);
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesUpdate(ticket_uuid: string, uuid: string, data: Models.MessageRequest): Promise<Models.Message> {
+    const response = await this.client.request('PUT', `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`, { body: data });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesPartialUpdate(ticket_uuid: string, uuid: string, data?: Models.PatchedMessageRequest): Promise<Models.Message> {
+    const response = await this.client.request('PATCH', `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`, { body: data });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support messages. Requires authenticated user (JWT
+   * or Session). Users can only access messages for their own tickets.
+   */
+  async ticketsMessagesDestroy(ticket_uuid: string, uuid: string): Promise<void> {
+    const response = await this.client.request('DELETE', `/cfg/support/tickets/${ticket_uuid}/messages/${uuid}/`);
+    return;
+  }
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsRetrieve(uuid: string): Promise<Models.Ticket> {
+    const response = await this.client.request('GET', `/cfg/support/tickets/${uuid}/`);
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsUpdate(uuid: string, data: Models.TicketRequest): Promise<Models.Ticket> {
+    const response = await this.client.request('PUT', `/cfg/support/tickets/${uuid}/`, { body: data });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsPartialUpdate(uuid: string, data?: Models.PatchedTicketRequest): Promise<Models.Ticket> {
+    const response = await this.client.request('PATCH', `/cfg/support/tickets/${uuid}/`, { body: data });
+    return response;
+  }
+
+  /**
+   * ViewSet for managing support tickets. Requires authenticated user (JWT
+   * or Session). Staff users can see all tickets, regular users see only
+   * their own.
+   */
+  async ticketsDestroy(uuid: string): Promise<void> {
+    const response = await this.client.request('DELETE', `/cfg/support/tickets/${uuid}/`);
+    return;
+  }
+
+}

package/src/api/generated/ext_support/ext_support__support/index.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * as Models from "./models";