@djangocfg/ext-knowbase 1.0.0

package/src/api/generated/ext_knowbase/http.ts

@@ -0,0 +1,103 @@
+/**
+ * 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;
+}
+
+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 } = 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 | 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 (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
+    let data: any = null;
+    const contentType = response.headers.get('content-type');
+
+    if (response.status !== 204 && contentType?.includes('application/json')) {
+      data = await response.json();
+    } else if (response.status !== 204) {
+      data = await response.text();
+    }
+
+    // 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,
+    };
+  }
+}

package/src/api/generated/ext_knowbase/index.ts

@@ -0,0 +1,273 @@
+/**
+ * Django CFG API - API Client with JWT Management
+ *
+ * Usage:
+ * ```typescript
+ * import { API } from './api';
+ *
+ * const api = new API('https://api.example.com');
+ *
+ * // Set JWT token
+ * api.setToken('your-jwt-token', 'refresh-token');
+ *
+ * // Use API
+ * const posts = await api.posts.list();
+ * const user = await api.users.retrieve(1);
+ *
+ * // Check authentication
+ * if (api.isAuthenticated()) {
+ *   // ...
+ * }
+ *
+ * // Custom storage with logging (for Electron/Node.js)
+ * import { MemoryStorageAdapter, APILogger } from './storage';
+ * const logger = new APILogger({ enabled: true, logLevel: 'debug' });
+ * const api = new API('https://api.example.com', {
+ *   storage: new MemoryStorageAdapter(logger),
+ *   loggerConfig: { enabled: true, logLevel: 'debug' }
+ * });
+ *
+ * // Get OpenAPI schema
+ * const schema = api.getSchema();
+ * ```
+ */
+
+import { APIClient } from "./client";
+import {
+  StorageAdapter,
+  LocalStorageAdapter,
+  CookieStorageAdapter,
+  MemoryStorageAdapter
+} from "./storage";
+import type { RetryConfig } from "./retry";
+import type { LoggerConfig } from "./logger";
+import { APILogger } from "./logger";
+import { ExtKnowbaseKnowbase } from "./ext_knowbase__knowbase/client";
+export * as ExtKnowbaseKnowbaseTypes from "./ext_knowbase__knowbase/models";
+// Note: Direct exports (export * from) are removed to avoid duplicate type conflicts
+// Use namespace exports like CfgAccountsTypes.User or import from specific modules
+export * as Enums from "./enums";
+
+// Re-export Zod schemas for runtime validation
+export * as Schemas from "./_utils/schemas";
+// Also export all schemas directly for convenience
+export * from "./_utils/schemas";
+
+// Re-export Zod validation events for browser integration
+export type { ValidationErrorDetail, ValidationErrorEvent } from "./validation-events";
+export { dispatchValidationError, onValidationError, formatZodError } from "./validation-events";
+
+// Re-export typed fetchers for universal usage
+export * as Fetchers from "./_utils/fetchers";
+export * from "./_utils/fetchers";
+
+// Re-export API instance configuration functions
+export {
+  configureAPI,
+  getAPIInstance,
+  reconfigureAPI,
+  clearAPITokens,
+  resetAPI,
+  isAPIConfigured
+} from "./api-instance";
+// NOTE: SWR hooks are generated in ./_utils/hooks/ but NOT exported here to keep
+// the main bundle server-safe. Import hooks directly from the hooks directory:
+//   import { useUsers } from './_utils/hooks';
+// Or use a separate entry point like '@djangocfg/api/hooks' for client components.
+
+// Re-export core client
+export { APIClient };
+
+// Re-export storage adapters for convenience
+export type { StorageAdapter };
+export { LocalStorageAdapter, CookieStorageAdapter, MemoryStorageAdapter };
+
+// Re-export error classes for convenience
+export { APIError, NetworkError } from "./errors";
+
+// Re-export HTTP adapters for custom implementations
+export type { HttpClientAdapter, HttpRequest, HttpResponse } from "./http";
+export { FetchAdapter } from "./http";
+
+// Re-export logger types and classes
+export type { LoggerConfig, RequestLog, ResponseLog, ErrorLog } from "./logger";
+export { APILogger } from "./logger";
+
+// Re-export retry configuration and utilities
+export type { RetryConfig, FailedAttemptInfo } from "./retry";
+export { withRetry, shouldRetry, DEFAULT_RETRY_CONFIG } from "./retry";
+
+export const TOKEN_KEY = "auth_token";
+export const REFRESH_TOKEN_KEY = "refresh_token";
+
+export interface APIOptions {
+  /** Custom storage adapter (defaults to LocalStorageAdapter) */
+  storage?: StorageAdapter;
+  /** Retry configuration for failed requests */
+  retryConfig?: RetryConfig;
+  /** Logger configuration */
+  loggerConfig?: Partial<LoggerConfig>;
+}
+
+export class API {
+  private baseUrl: string;
+  private _client: APIClient;
+  private _token: string | null = null;
+  private _refreshToken: string | null = null;
+  private storage: StorageAdapter;
+  private options?: APIOptions;
+
+  // Sub-clients
+  public ext_knowbase_knowbase!: ExtKnowbaseKnowbase;
+
+  constructor(baseUrl: string, options?: APIOptions) {
+    this.baseUrl = baseUrl;
+    this.options = options;
+
+    // Create logger if config provided
+    const logger = options?.loggerConfig ? new APILogger(options.loggerConfig) : undefined;
+
+    // Initialize storage with logger
+    this.storage = options?.storage || new LocalStorageAdapter(logger);
+
+    this._loadTokensFromStorage();
+
+    // Initialize APIClient
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig,
+    });
+
+    // Always inject auth header wrapper (reads token dynamically from storage)
+    this._injectAuthHeader();
+
+    // Initialize sub-clients from APIClient
+    this.ext_knowbase_knowbase = this._client.ext_knowbase_knowbase;
+  }
+
+  private _loadTokensFromStorage(): void {
+    this._token = this.storage.getItem(TOKEN_KEY);
+    this._refreshToken = this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+
+  private _reinitClients(): void {
+    this._client = new APIClient(this.baseUrl, {
+      retryConfig: this.options?.retryConfig,
+      loggerConfig: this.options?.loggerConfig,
+    });
+
+    // Always inject auth header wrapper (reads token dynamically from storage)
+    this._injectAuthHeader();
+
+    // Reinitialize sub-clients
+    this.ext_knowbase_knowbase = this._client.ext_knowbase_knowbase;
+  }
+
+  private _injectAuthHeader(): void {
+    // Override request method to inject auth header
+    const originalRequest = this._client.request.bind(this._client);
+    this._client.request = async <T>(
+      method: string,
+      path: string,
+      options?: { params?: Record<string, any>; body?: any; formData?: FormData; headers?: Record<string, string> }
+    ): Promise<T> => {
+      // Read token from storage dynamically (supports JWT injection after instantiation)
+      const token = this.getToken();
+      const mergedOptions = {
+        ...options,
+        headers: {
+          ...(options?.headers || {}),
+          ...(token ? { 'Authorization': `Bearer ${token}` } : {}),
+        },
+      };
+
+      return originalRequest(method, path, mergedOptions);
+    };
+  }
+
+  /**
+   * Get current JWT token
+   */
+  getToken(): string | null {
+    return this.storage.getItem(TOKEN_KEY);
+  }
+
+  /**
+   * Get current refresh token
+   */
+  getRefreshToken(): string | null {
+    return this.storage.getItem(REFRESH_TOKEN_KEY);
+  }
+
+  /**
+   * Set JWT token and refresh token
+   * @param token - JWT access token
+   * @param refreshToken - JWT refresh token (optional)
+   */
+  setToken(token: string, refreshToken?: string): void {
+    this._token = token;
+    this.storage.setItem(TOKEN_KEY, token);
+
+    if (refreshToken) {
+      this._refreshToken = refreshToken;
+      this.storage.setItem(REFRESH_TOKEN_KEY, refreshToken);
+    }
+
+    // Reinitialize clients with new token
+    this._reinitClients();
+  }
+
+  /**
+   * Clear all tokens
+   */
+  clearTokens(): void {
+    this._token = null;
+    this._refreshToken = null;
+    this.storage.removeItem(TOKEN_KEY);
+    this.storage.removeItem(REFRESH_TOKEN_KEY);
+
+    // Reinitialize clients without token
+    this._reinitClients();
+  }
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated(): boolean {
+    return !!this.getToken();
+  }
+
+  /**
+   * Update base URL and reinitialize clients
+   * @param url - New base URL
+   */
+  setBaseUrl(url: string): void {
+    this.baseUrl = url;
+    this._reinitClients();
+  }
+
+  /**
+   * Get current base URL
+   */
+  getBaseUrl(): string {
+    return this.baseUrl;
+  }
+
+  /**
+   * Get OpenAPI schema path
+   * @returns Path to the OpenAPI schema JSON file
+   *
+   * Note: The OpenAPI schema is available in the schema.json file.
+   * You can load it dynamically using:
+   * ```typescript
+   * const schema = await fetch('./schema.json').then(r => r.json());
+   * // or using fs in Node.js:
+   * // const schema = JSON.parse(fs.readFileSync('./schema.json', 'utf-8'));
+   * ```
+   */
+  getSchemaPath(): string {
+    return './schema.json';
+  }
+}
+
+export default API;

package/src/api/generated/ext_knowbase/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();