@djangocfg/ext-knowbase 1.0.0

package/src/api/generated/ext_knowbase/_utils/schemas/PublicDocumentList.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for PublicDocumentList
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Public document list serializer - minimal fields for listing.
+ *  */
+import { z } from 'zod'
+import { PublicCategorySchema } from './PublicCategory.schema'
+
+/**
+ * Public document list serializer - minimal fields for listing.
+ */
+export const PublicDocumentListSchema = 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),
+  title: z.string().max(512),
+  category: PublicCategorySchema,
+  created_at: z.iso.datetime(),
+  updated_at: z.iso.datetime(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type PublicDocumentList = z.infer<typeof PublicDocumentListSchema>

package/src/api/generated/ext_knowbase/_utils/schemas/VectorizationResult.schema.ts

@@ -0,0 +1,24 @@
+/**
+ * Zod schema for VectorizationResult
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Vectorization result serializer.
+ *  */
+import { z } from 'zod'
+
+/**
+ * Vectorization result serializer.
+ */
+export const VectorizationResultSchema = z.object({
+  vectorized_count: z.int(),
+  failed_count: z.int(),
+  total_tokens: z.int(),
+  total_cost: z.number(),
+  success_rate: z.number(),
+  errors: z.array(z.string()),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type VectorizationResult = z.infer<typeof VectorizationResultSchema>

package/src/api/generated/ext_knowbase/_utils/schemas/VectorizationStatistics.schema.ts

@@ -0,0 +1,26 @@
+/**
+ * Zod schema for VectorizationStatistics
+ *
+ * This schema provides runtime validation and type inference.
+ *  * Vectorization statistics serializer.
+ *  */
+import { z } from 'zod'
+
+/**
+ * Vectorization statistics serializer.
+ */
+export const VectorizationStatisticsSchema = z.object({
+  total_chunks: z.int(),
+  vectorized_chunks: z.int(),
+  pending_chunks: z.int(),
+  vectorization_rate: z.number(),
+  total_tokens: z.int(),
+  total_cost: z.number(),
+  avg_tokens_per_chunk: z.number(),
+  avg_cost_per_chunk: z.number(),
+})
+
+/**
+ * Infer TypeScript type from Zod schema
+ */
+export type VectorizationStatistics = z.infer<typeof VectorizationStatisticsSchema>

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

@@ -0,0 +1,70 @@
+/**
+ * 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 './ArchiveItem.schema'
+export * from './ArchiveItemChunk.schema'
+export * from './ArchiveItemChunkDetail.schema'
+export * from './ArchiveItemChunkRequest.schema'
+export * from './ArchiveItemDetail.schema'
+export * from './ArchiveItemRequest.schema'
+export * from './ArchiveProcessingResult.schema'
+export * from './ArchiveSearchRequestRequest.schema'
+export * from './ArchiveSearchResult.schema'
+export * from './ArchiveStatistics.schema'
+export * from './ChatHistory.schema'
+export * from './ChatMessage.schema'
+export * from './ChatQueryRequest.schema'
+export * from './ChatResponse.schema'
+export * from './ChatResponseRequest.schema'
+export * from './ChatSession.schema'
+export * from './ChatSessionCreateRequest.schema'
+export * from './ChatSessionRequest.schema'
+export * from './ChatSource.schema'
+export * from './ChatSourceRequest.schema'
+export * from './ChunkRevectorizationRequestRequest.schema'
+export * from './Document.schema'
+export * from './DocumentArchive.schema'
+export * from './DocumentArchiveDetail.schema'
+export * from './DocumentArchiveList.schema'
+export * from './DocumentArchiveRequest.schema'
+export * from './DocumentCategory.schema'
+export * from './DocumentCategoryRequest.schema'
+export * from './DocumentCreateRequest.schema'
+export * from './DocumentProcessingStatus.schema'
+export * from './DocumentRequest.schema'
+export * from './DocumentStats.schema'
+export * from './PaginatedArchiveItemChunkList.schema'
+export * from './PaginatedArchiveItemList.schema'
+export * from './PaginatedArchiveSearchResultList.schema'
+export * from './PaginatedChatResponseList.schema'
+export * from './PaginatedChatSessionList.schema'
+export * from './PaginatedDocumentArchiveListList.schema'
+export * from './PaginatedDocumentList.schema'
+export * from './PaginatedPublicCategoryList.schema'
+export * from './PaginatedPublicDocumentListList.schema'
+export * from './PatchedArchiveItemChunkRequest.schema'
+export * from './PatchedArchiveItemRequest.schema'
+export * from './PatchedChatResponseRequest.schema'
+export * from './PatchedChatSessionRequest.schema'
+export * from './PatchedDocumentArchiveRequest.schema'
+export * from './PatchedDocumentRequest.schema'
+export * from './PublicCategory.schema'
+export * from './PublicDocument.schema'
+export * from './PublicDocumentList.schema'
+export * from './VectorizationResult.schema'
+export * from './VectorizationStatistics.schema'

package/src/api/generated/ext_knowbase/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_knowbase/client.ts

@@ -0,0 +1,301 @@
+import { ExtKnowbaseKnowbase } from "./ext_knowbase__knowbase";
+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_knowbase_knowbase: ExtKnowbaseKnowbase;
+
+  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_knowbase_knowbase = new ExtKnowbaseKnowbase(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;
+    }
+  }
+}