@retrivora-ai/rag-engine 0.4.5 → 1.0.0

package/src/core/ProviderHealthCheck.ts

@@ -1,24 +1,14 @@
-/**
- * ProviderHealthCheck.ts — Pre-flight validation for vector DB and LLM providers.
- *
- * Performs connectivity tests, credential validation, and capability checks
- * before initializing providers.
- *
- * Note: Option keys used here mirror each Provider constructor's expected keys.
- */
-
 import { VectorDBConfig, LLMConfig, EmbeddingConfig } from '../config/RagConfig';
 import { ConfigValidator } from './ConfigValidator';
+import { ProviderRegistry } from './ProviderRegistry';
+import { LLMFactory } from '../llm/LLMFactory';
+import type { HealthCheckResult } from './ProviderInterfaces';
+export type { HealthCheckResult };
 
-export interface HealthCheckResult {
-  healthy: boolean;
-  provider: string;
-  version?: string;
-  capabilities?: Record<string, unknown>;
-  error?: string;
-  timestamp: number;
-}
-
+/**
+ * ProviderHealthCheck.ts — Pre-flight validation for vector DB and LLM providers.
+ * Performs connectivity tests, credential validation, and capability checks.
+ */
 export class ProviderHealthCheck {
   /**
    * Validates vector database configuration before initialization.
@@ -26,12 +16,11 @@ export class ProviderHealthCheck {
   static async checkVectorProvider(config: VectorDBConfig): Promise<HealthCheckResult> {
     const timestamp = Date.now();
 
-    // Validate configuration first
-    const configErrors = ConfigValidator.validate({
+    const configErrors = await ConfigValidator.validate({
       projectId: 'health-check',
       vectorDb: config,
-      llm: { provider: 'openai', model: 'gpt-4o' },
-      embedding: { provider: 'openai', model: 'text-embedding-3-small' },
+      llm: { provider: 'openai', model: 'gpt-4o', apiKey: 'none' },
+      embedding: { provider: 'openai', model: 'text-embedding-3-small', apiKey: 'none' },
     });
 
     const vectorDbErrors = configErrors.filter((e) => e.field.startsWith('vectorDb'));
@@ -45,35 +34,13 @@ export class ProviderHealthCheck {
     }
 
     try {
-      switch (config.provider) {
-        case 'pinecone':
-          return await this.checkPinecone(config, timestamp);
-        case 'pgvector':
-        case 'postgresql':
-          return await this.checkPostgres(config, timestamp);
-        case 'mongodb':
-          return await this.checkMongoDB(config, timestamp);
-        case 'milvus':
-          return await this.checkMilvus(config, timestamp);
-        case 'qdrant':
-          return await this.checkQdrant(config, timestamp);
-        case 'chromadb':
-          return await this.checkChromaDB(config, timestamp);
-        case 'redis':
-          return await this.checkRedis(config, timestamp);
-        case 'weaviate':
-          return await this.checkWeaviate(config, timestamp);
-        case 'rest':
-        case 'universal_rest':
-          return await this.checkRestAPI(config, timestamp);
-        default:
-          return {
-            healthy: false,
-            provider: config.provider,
-            error: `Unsupported provider: ${config.provider}`,
-            timestamp,
-          };
+      const checker = await ProviderRegistry.getVectorHealthChecker(config.provider);
+      if (checker) {
+        return await checker.check(config as unknown as Record<string, unknown>);
       }
+      
+      // Fallback for non-migrated providers
+      return await this.fallbackVectorHealthCheck(config, timestamp);
     } catch (error) {
       return {
         healthy: false,
@@ -84,392 +51,54 @@ export class ProviderHealthCheck {
     }
   }
 
-  private static async checkPinecone(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    try {
-      const { Pinecone } = await import('@pinecone-database/pinecone');
-      const client = new Pinecone({ apiKey: opts.apiKey });
-      const indexes = await client.listIndexes();
-      const indexNames = indexes.indexes?.map((i) => i.name) ?? [];
+  private static async fallbackVectorHealthCheck(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
+    const opts = (config.options || {}) as Record<string, unknown>;
+    const baseUrl = (opts.baseUrl as string) || (opts.uri as string);
 
-      if (!indexNames.includes(config.indexName)) {
+    if (baseUrl && baseUrl.startsWith('http')) {
+      try {
+        const response = await fetch(`${baseUrl.replace(/\/$/, '')}/health`);
         return {
-          healthy: false,
-          provider: 'pinecone',
-          error: `Index "${config.indexName}" not found. Available: ${indexNames.join(', ')}`,
+          healthy: response.ok,
+          provider: config.provider,
+          error: response.ok ? undefined : `Health check failed: ${response.status}`,
           timestamp,
         };
-      }
-      return {
-        healthy: true,
-        provider: 'pinecone',
-        capabilities: { indexes: indexNames.length, targetIndex: config.indexName },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'pinecone',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkPostgres(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    try {
-      const { Client } = await import('pg');
-      const client = new Client({ connectionString: opts.connectionString });
-      await client.connect();
-      const result = await client.query(`
-        SELECT EXISTS(SELECT 1 FROM pg_extension WHERE extname = 'vector');
-      `);
-      const hasVector = result.rows[0].exists;
-      await client.end();
-      return {
-        healthy: true,
-        provider: 'postgresql',
-        capabilities: { pgvectorInstalled: hasVector },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'postgresql',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkMongoDB(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    try {
-      const { MongoClient } = await import('mongodb');
-      const client = new MongoClient(opts.uri);
-      await client.connect();
-      const db = client.db(opts.database);
-      const collections = await db.listCollections().toArray();
-      const collectionNames = collections.map((c) => c.name);
-      const hasCollection = collectionNames.includes(opts.collection);
-      await client.close();
-      return {
-        healthy: true,
-        provider: 'mongodb',
-        capabilities: {
-          collections: collectionNames.length,
-          targetCollection: hasCollection ? opts.collection : 'NOT FOUND (will be created on first insert)',
-        },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'mongodb',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  /**
-   * Milvus health check — uses baseUrl/uri (matching MilvusProvider constructor).
-   */
-  private static async checkMilvus(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, unknown>;
-
-    // Resolve endpoint — mirrors MilvusProvider constructor logic
-    const baseUrl =
-      (opts.baseUrl as string) ||
-      (opts.uri as string) ||
-      (opts.host ? `http://${opts.host}:${(opts.port as number) || 19530}` : 'http://localhost:19530');
-
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 5000);
-      const response = await fetch(`${baseUrl}/v1/health`, { signal: controller.signal });
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        throw new Error(`Health check returned ${response.status}`);
-      }
-      return {
-        healthy: true,
-        provider: 'milvus',
-        capabilities: { endpoint: baseUrl },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'milvus',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  /**
-   * Qdrant health check — uses baseUrl (matching QdrantProvider constructor).
-   */
-  private static async checkQdrant(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, unknown>;
-    const baseUrl = ((opts.baseUrl as string) || (opts.url as string) || 'http://localhost:6333').replace(/\/$/, '');
-    try {
-      const apiKey = opts.apiKey as string | undefined;
-      const response = await fetch(`${baseUrl}/`, {
-        headers: apiKey ? { 'api-key': apiKey } : {},
-      });
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      const health = await response.json();
-      return {
-        healthy: true,
-        provider: 'qdrant',
-        capabilities: health as Record<string, unknown>,
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'qdrant',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  /**
-   * ChromaDB health check — uses baseUrl/host (matching ChromaDBProvider constructor).
-   */
-  private static async checkChromaDB(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, unknown>;
-
-    // Mirrors ChromaDBProvider constructor
-    const baseUrl =
-      (opts.baseUrl as string) ||
-      (opts.host ? `http://${opts.host}:${(opts.port as number) || 8000}` : 'http://localhost:8000');
-
-    try {
-      const response = await fetch(`${baseUrl}/api/v1/heartbeat`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      return {
-        healthy: true,
-        provider: 'chromadb',
-        capabilities: { endpoint: baseUrl },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'chromadb',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  /**
-   * Redis health check — Redis is TCP-only (no HTTP endpoint).
-   * We report healthy=true with a note; actual connectivity is validated at first operation.
-   */
-  private static async checkRedis(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    const url =
-      opts.baseUrl || opts.url || (opts.host && opts.port ? `redis://${opts.host}:${opts.port}` : 'redis://localhost:6379');
-
-    // For Upstash REST endpoints, try an HTTP ping
-    if (url.startsWith('http')) {
-      try {
-        await fetch(url);
-        return { healthy: true, provider: 'redis', capabilities: { endpoint: url }, timestamp };
       } catch {
-        // Ignore — Upstash may reject GET but accept POST
+        return { healthy: false, provider: config.provider, error: 'Provider unreachable', timestamp };
       }
     }
 
     return {
       healthy: true,
-      provider: 'redis',
-      capabilities: {
-        endpoint: url,
-        note: 'Redis uses TCP; connectivity is validated on first operation.',
-      },
+      provider: config.provider,
+      error: 'Pluggable health check not implemented; basic reachability assumed.',
       timestamp,
     };
   }
 
-  /**
-   * Weaviate health check — uses baseUrl/url (matching WeaviateProvider constructor).
-   */
-  private static async checkWeaviate(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    const baseUrl = ((opts.baseUrl || opts.url) || 'http://localhost:8080').replace(/\/$/, '');
-    try {
-      const response = await fetch(`${baseUrl}/v1/.well-known/ready`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      return {
-        healthy: true,
-        provider: 'weaviate',
-        capabilities: { endpoint: baseUrl },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'weaviate',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkRestAPI(config: VectorDBConfig, timestamp: number): Promise<HealthCheckResult> {
-    const opts = config.options as Record<string, string>;
-    const baseUrl = (opts.baseUrl || '').replace(/\/$/, '');
-    if (!baseUrl) {
-      return { healthy: false, provider: 'rest', error: 'baseUrl is required', timestamp };
-    }
-    try {
-      const response = await fetch(`${baseUrl}/health`, {
-        headers: opts.headers ? JSON.parse(opts.headers) : {},
-      });
-      return {
-        healthy: response.ok,
-        provider: 'rest',
-        error: response.ok ? undefined : `Health check returned ${response.status}`,
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'rest',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
   /**
    * Validates LLM provider configuration.
    */
   static async checkLLMProvider(config: LLMConfig): Promise<HealthCheckResult> {
     const timestamp = Date.now();
     try {
-      switch (config.provider) {
-        case 'openai':
-          return await this.checkOpenAI(config, timestamp);
-        case 'anthropic':
-          return await this.checkAnthropic(config, timestamp);
-        case 'ollama':
-          return await this.checkOllama(config, timestamp);
-        case 'rest':
-        case 'universal_rest':
-          return await this.checkLLMRestAPI(config, timestamp);
-        default:
-          return {
-            healthy: false,
-            provider: config.provider,
-            error: `Unsupported provider: ${config.provider}`,
-            timestamp,
-          };
+      const checker = LLMFactory.getHealthChecker(config.provider);
+      if (checker) {
+        return await checker.check(config as unknown as Record<string, unknown>);
       }
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: config.provider,
-        error: error instanceof Error ? error.message : String(error),
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkOpenAI(config: LLMConfig, timestamp: number): Promise<HealthCheckResult> {
-    try {
-      const OpenAI = await import('openai');
-      const client = new OpenAI.default({ apiKey: config.apiKey });
-      const models = await client.models.list();
-      const hasModel = models.data.some((m) => m.id === config.model);
+      
       return {
         healthy: true,
-        provider: 'openai',
-        capabilities: { model: config.model, available: hasModel, totalModels: models.data.length },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'openai',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkAnthropic(config: LLMConfig, timestamp: number): Promise<HealthCheckResult> {
-    try {
-      const { default: Anthropic } = await import('@anthropic-ai/sdk');
-      const client = new Anthropic({ apiKey: config.apiKey });
-      await client.messages.create({
-        model: config.model,
-        max_tokens: 10,
-        messages: [{ role: 'user', content: 'ping' }],
-      });
-      return { healthy: true, provider: 'anthropic', capabilities: { model: config.model }, timestamp };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'anthropic',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkOllama(config: LLMConfig, timestamp: number): Promise<HealthCheckResult> {
-    const baseUrl = (config.baseUrl || 'http://localhost:11434').replace(/\/$/, '');
-    try {
-      const response = await fetch(`${baseUrl}/api/tags`);
-      if (!response.ok) throw new Error(`Health check returned ${response.status}`);
-      const data = await response.json() as Record<string, unknown>;
-      const models = (data.models as Array<{ name: string }>) || [];
-      const hasModel = models.some((m) => m.name === config.model);
-      return {
-        healthy: true,
-        provider: 'ollama',
-        capabilities: { model: config.model, available: hasModel, totalModels: models.length },
-        timestamp,
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        provider: 'ollama',
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
-        timestamp,
-      };
-    }
-  }
-
-  private static async checkLLMRestAPI(config: LLMConfig, timestamp: number): Promise<HealthCheckResult> {
-    const baseUrlRaw = config.baseUrl || (config.options as Record<string, unknown>)?.baseUrl;
-    const baseUrl = (typeof baseUrlRaw === 'string' ? baseUrlRaw : '').replace(/\/$/, '');
-    if (!baseUrl) {
-      return { healthy: false, provider: config.provider, error: 'baseUrl is required', timestamp };
-    }
-    try {
-      const headers = (config.options as Record<string, unknown>)?.headers as Record<string, string> | undefined;
-      const response = await fetch(`${baseUrl}/health`, { headers: headers || undefined });
-      return {
-        healthy: response.ok,
         provider: config.provider,
-        error: response.ok ? undefined : `Health check returned ${response.status}`,
+        error: 'Pluggable health check not implemented; basic reachability assumed.',
         timestamp,
       };
     } catch (error) {
       return {
         healthy: false,
         provider: config.provider,
-        error: `Connection failed: ${error instanceof Error ? error.message : String(error)}`,
+        error: error instanceof Error ? error.message : String(error),
         timestamp,
       };
     }

package/src/core/ProviderInterfaces.ts

@@ -0,0 +1,37 @@
+import { ValidationError } from './ConfigValidator';
+
+/**
+ * Interface for provider-specific configuration validation logic.
+ */
+export interface IProviderValidator {
+  /**
+   * Validates the configuration for a specific provider.
+   * @param config - The configuration object to validate.
+   * @returns An array of validation errors (empty if valid).
+   */
+  validate(config: Record<string, unknown>): ValidationError[];
+}
+
+/**
+ * Result of a provider health check.
+ */
+export interface HealthCheckResult {
+  healthy: boolean;
+  provider: string;
+  version?: string;
+  capabilities?: Record<string, unknown>;
+  error?: string;
+  timestamp: number;
+}
+
+/**
+ * Interface for provider-specific health checking logic.
+ */
+export interface IProviderHealthChecker {
+  /**
+   * Performs a health check for a specific provider.
+   * @param config - The configuration object used to connect to the provider.
+   * @returns A promise that resolves to the health check result.
+   */
+  check(config: Record<string, unknown>): Promise<HealthCheckResult>;
+}