@djangocfg/ext-payments 1.0.0

package/src/api/generated/ext_payments/_utils/schemas/Balance.schema.ts

@@ -0,0 +1,23 @@
+/**
+ * Zod schema for Balance
+ *
+ * This schema provides runtime validation and type inference.
+ *  * User balance serializer.
+ *  */
+import { z } from 'zod'
+
+/**
+ * User balance serializer.
+ */
+export const BalanceSchema = z.object({
+  balance_usd: z.string(),
+  balance_display: z.string(),
+  total_deposited: z.string(),
+  total_withdrawn: z.string(),
+  last_transaction_at: z.iso.datetime().nullable(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Balance = z.infer<typeof BalanceSchema>

package/src/api/generated/ext_payments/_utils/schemas/Currency.schema.ts

@@ -0,0 +1,28 @@
+/**
+ * Zod schema for Currency
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Currency list serializer.
+ *  */
+import { z } from 'zod'
+
+/**
+ * Currency list serializer.
+ */
+export const CurrencySchema = z.object({
+  code: z.string(),
+  name: z.string(),
+  token: z.string(),
+  network: z.string().nullable(),
+  display_name: z.string(),
+  symbol: z.string(),
+  decimal_places: z.int(),
+  is_active: z.boolean(),
+  min_amount_usd: z.string(),
+  sort_order: z.int(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Currency = z.infer<typeof CurrencySchema>

package/src/api/generated/ext_payments/_utils/schemas/PaginatedPaymentListList.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for PaginatedPaymentListList
+ *
+ * This schema provides runtime validation and type inference.
+ *  */
+import { z } from 'zod'
+import { PaymentListSchema } from './PaymentList.schema'
+
+export const PaginatedPaymentListListSchema = z.object({
+  count: z.int(),
+  page: z.int(),
+  pages: z.int(),
+  page_size: z.int(),
+  has_next: z.boolean(),
+  has_previous: z.boolean(),
+  next_page: z.int().nullable().optional(),
+  previous_page: z.int().nullable().optional(),
+  results: z.array(PaymentListSchema),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PaginatedPaymentListList = z.infer<typeof PaginatedPaymentListListSchema>

package/src/api/generated/ext_payments/_utils/schemas/PaymentDetail.schema.ts

@@ -0,0 +1,44 @@
+/**
+ * Zod schema for PaymentDetail
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Detailed payment information.
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+/**
+ * Detailed payment information.
+ */
+export const PaymentDetailSchema = z.object({
+  id: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  internal_payment_id: z.string(),
+  amount_usd: z.string(),
+  currency_code: z.string(),
+  currency_name: z.string(),
+  currency_token: z.string(),
+  currency_network: z.string(),
+  pay_amount: z.string().nullable(),
+  actual_amount: z.string().nullable(),
+  actual_amount_usd: z.string().nullable(),
+  status: z.nativeEnum(Enums.PaymentDetailStatus),
+  status_display: z.string(),
+  pay_address: z.string().nullable(),
+  qr_code_url: z.string().nullable(),
+  payment_url: z.url().nullable(),
+  transaction_hash: z.string().nullable(),
+  explorer_link: z.string().nullable(),
+  confirmations_count: z.int(),
+  expires_at: z.iso.datetime().nullable(),
+  completed_at: z.iso.datetime().nullable(),
+  created_at: z.iso.datetime(),
+  is_completed: z.boolean(),
+  is_failed: z.boolean(),
+  is_expired: z.boolean(),
+  description: z.string(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PaymentDetail = z.infer<typeof PaymentDetailSchema>

package/src/api/generated/ext_payments/_utils/schemas/PaymentList.schema.ts

@@ -0,0 +1,28 @@
+/**
+ * Zod schema for PaymentList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Payment list item (lighter than detail).
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+/**
+ * Payment list item (lighter than detail).
+ */
+export const PaymentListSchema = z.object({
+  id: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  internal_payment_id: z.string(),
+  amount_usd: z.string(),
+  currency_code: z.string(),
+  currency_token: z.string(),
+  status: z.nativeEnum(Enums.PaymentListStatus),
+  status_display: z.string(),
+  created_at: z.iso.datetime(),
+  completed_at: z.iso.datetime().nullable(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PaymentList = z.infer<typeof PaymentListSchema>

package/src/api/generated/ext_payments/_utils/schemas/Transaction.schema.ts

@@ -0,0 +1,28 @@
+/**
+ * Zod schema for Transaction
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Transaction serializer.
+ *  */
+import { z } from 'zod'
+import * as Enums from '../../enums'
+
+/**
+ * Transaction serializer.
+ */
+export const TransactionSchema = z.object({
+  id: z.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i),
+  transaction_type: z.nativeEnum(Enums.TransactionTransactionType),
+  type_display: z.string(),
+  amount_usd: z.string(),
+  amount_display: z.string(),
+  balance_after: z.string(),
+  payment_id: z.string().nullable(),
+  description: z.string(),
+  created_at: z.iso.datetime(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type Transaction = z.infer<typeof TransactionSchema>

package/src/api/generated/ext_payments/_utils/schemas/index.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod Schemas - Runtime validation and type inference
+ *
+ * Auto-generated from OpenAPI specification.
+ * Provides runtime validation for API requests and responses.
+ *
+ * Usage:
+ * ```typescript
+ * import { UserSchema } from './schemas'
+ *
+ * // Validate data
+ * const user = UserSchema.parse(data)
+ *
+ * // Type inference
+ * type User = z.infer<typeof UserSchema>
+ * ```
+ */
+
+export * from './Balance.schema'
+export * from './Currency.schema'
+export * from './PaginatedPaymentListList.schema'
+export * from './PaymentDetail.schema'
+export * from './PaymentList.schema'
+export * from './Transaction.schema'

package/src/api/generated/ext_payments/api-instance.ts

@@ -0,0 +1,131 @@
+/**
+ * Global API Instance - Singleton configuration
+ *
+ * This module provides a global API instance that can be configured once
+ * and used throughout your application.
+ *
+ * Usage:
+ * ```typescript
+ * // Configure once (e.g., in your app entry point)
+ * import { configureAPI } from './api-instance'
+ *
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'your-jwt-token'
+ * })
+ *
+ * // Then use fetchers and hooks anywhere without configuration
+ * import { getUsers } from './fetchers'
+ * const users = await getUsers({ page: 1 })
+ * ```
+ *
+ * For SSR or multiple instances:
+ * ```typescript
+ * import { API } from './index'
+ * import { getUsers } from './fetchers'
+ *
+ * const api = new API('https://api.example.com')
+ * const users = await getUsers({ page: 1 }, api)
+ * ```
+ */
+
+import { API, type APIOptions } from './index'
+
+let globalAPI: API | null = null
+
+/**
+ * Get the global API instance
+ * @throws Error if API is not configured
+ */
+export function getAPIInstance(): API {
+  if (!globalAPI) {
+    throw new Error(
+      'API not configured. Call configureAPI() with your base URL before using fetchers or hooks.\n\n' +
+      'Example:\n' +
+      '  import { configureAPI } from "./api-instance"\n' +
+      '  configureAPI({ baseUrl: "https://api.example.com" })'
+    )
+  }
+  return globalAPI
+}
+
+/**
+ * Check if API is configured
+ */
+export function isAPIConfigured(): boolean {
+  return globalAPI !== null
+}
+
+/**
+ * Configure the global API instance
+ *
+ * @param baseUrl - Base URL for the API
+ * @param options - Optional configuration (storage, retry, logger)
+ *
+ * @example
+ * ```typescript
+ * configureAPI({
+ *   baseUrl: 'https://api.example.com',
+ *   token: 'jwt-token',
+ *   options: {
+ *     retryConfig: { maxRetries: 3 },
+ *     loggerConfig: { enabled: true }
+ *   }
+ * })
+ * ```
+ */
+export function configureAPI(config: {
+  baseUrl: string
+  token?: string
+  refreshToken?: string
+  options?: APIOptions
+}): API {
+  globalAPI = new API(config.baseUrl, config.options)
+
+  if (config.token) {
+    globalAPI.setToken(config.token, config.refreshToken)
+  }
+
+  return globalAPI
+}
+
+/**
+ * Reconfigure the global API instance with new settings
+ * Useful for updating tokens or base URL
+ */
+export function reconfigureAPI(updates: {
+  baseUrl?: string
+  token?: string
+  refreshToken?: string
+}): API {
+  const instance = getAPIInstance()
+
+  if (updates.baseUrl) {
+    instance.setBaseUrl(updates.baseUrl)
+  }
+
+  if (updates.token) {
+    instance.setToken(updates.token, updates.refreshToken)
+  }
+
+  return instance
+}
+
+/**
+ * Clear tokens from the global API instance
+ */
+export function clearAPITokens(): void {
+  const instance = getAPIInstance()
+  instance.clearTokens()
+}
+
+/**
+ * Reset the global API instance
+ * Useful for testing or logout scenarios
+ */
+export function resetAPI(): void {
+  if (globalAPI) {
+    globalAPI.clearTokens()
+  }
+  globalAPI = null
+}

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

@@ -0,0 +1,301 @@
+import { ExtPaymentsPayments } from "./ext_payments__payments";
+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_payments_payments: ExtPaymentsPayments;
+
+  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_payments_payments = new ExtPaymentsPayments(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_payments/enums.ts

@@ -0,0 +1,64 @@
+/**
+ * Current payment status
+ * * `pending` - Pending
+ * * `confirming` - Confirming
+ * * `confirmed` - Confirmed
+ * * `completed` - Completed
+ * * `partially_paid` - Partially Paid
+ * * `failed` - Failed
+ * * `expired` - Expired
+ * * `cancelled` - Cancelled
+ */
+export enum PaymentDetailStatus {
+  PENDING = "pending",
+  CONFIRMING = "confirming",
+  CONFIRMED = "confirmed",
+  COMPLETED = "completed",
+  PARTIALLY_PAID = "partially_paid",
+  FAILED = "failed",
+  EXPIRED = "expired",
+  CANCELLED = "cancelled",
+}
+
+/**
+ * Current payment status
+ * * `pending` - Pending
+ * * `confirming` - Confirming
+ * * `confirmed` - Confirmed
+ * * `completed` - Completed
+ * * `partially_paid` - Partially Paid
+ * * `failed` - Failed
+ * * `expired` - Expired
+ * * `cancelled` - Cancelled
+ */
+export enum PaymentListStatus {
+  PENDING = "pending",
+  CONFIRMING = "confirming",
+  CONFIRMED = "confirmed",
+  COMPLETED = "completed",
+  PARTIALLY_PAID = "partially_paid",
+  FAILED = "failed",
+  EXPIRED = "expired",
+  CANCELLED = "cancelled",
+}
+
+/**
+ * Type of transaction
+ * * `deposit` - Deposit
+ * * `withdrawal` - Withdrawal
+ * * `payment` - Payment
+ * * `refund` - Refund
+ * * `fee` - Fee
+ * * `bonus` - Bonus
+ * * `adjustment` - Adjustment
+ */
+export enum TransactionTransactionType {
+  DEPOSIT = "deposit",
+  WITHDRAWAL = "withdrawal",
+  PAYMENT = "payment",
+  REFUND = "refund",
+  FEE = "fee",
+  BONUS = "bonus",
+  ADJUSTMENT = "adjustment",
+}
+