family-ai-agent 1.0.5 → 1.0.7

package/src/database/adapters/index.ts

@@ -0,0 +1,224 @@
+/**
+ * Database Adapter Factory
+ *
+ * Factory for creating database adapters with auto-detection support.
+ * Tries PostgreSQL first, falls back to SQLite automatically.
+ */
+
+import pg from 'pg';
+
+import { PostgresAdapter } from './postgres-adapter.js';
+import { SQLiteAdapter } from './sqlite-adapter.js';
+import { BaseAdapter } from './base-adapter.js';
+import { getDatabaseConfig, buildPostgresUrl, getDefaultSqlitePath } from '../db-config.js';
+import type { DatabaseAdapter, DetectionResult, DatabaseConfig } from '../types.js';
+import { createLogger } from '../../utils/logger.js';
+
+const { Pool } = pg;
+const logger = createLogger('AdapterFactory');
+
+// Singleton adapter instance
+let adapterInstance: DatabaseAdapter | null = null;
+let initPromise: Promise<DatabaseAdapter> | null = null;
+
+/**
+ * Detect which database to use
+ */
+export async function detectDatabase(config: DatabaseConfig): Promise<DetectionResult> {
+  // 1. Check for explicit configuration
+  if (config.type !== 'auto') {
+    if (config.type === 'postgresql') {
+      return {
+        type: 'postgresql',
+        connectionString: config.postgresUrl ?? buildPostgresUrl({
+          DATABASE_URL: config.postgresUrl,
+          DB_HOST: config.postgresHost,
+          DB_PORT: config.postgresPort,
+          DB_USER: config.postgresUser,
+          DB_PASSWORD: config.postgresPassword,
+          DB_NAME: config.postgresDatabase,
+          DB_POOL_MAX: config.postgresPoolMax,
+          DB_POOL_IDLE_TIMEOUT_MS: config.postgresIdleTimeoutMs,
+          DB_POOL_CONNECTION_TIMEOUT_MS: config.postgresConnectionTimeoutMs,
+          DATABASE_TYPE: 'postgresql',
+          SQLITE_PATH: config.sqlitePath,
+          DB_HEALTH_CHECK_INTERVAL_MS: config.healthCheckIntervalMs,
+          DB_CIRCUIT_BREAKER_THRESHOLD: config.circuitBreakerThreshold,
+          DB_CIRCUIT_BREAKER_TIMEOUT_MS: config.circuitBreakerTimeoutMs,
+          DB_CACHE_MAX_SIZE: config.cacheMaxSize,
+          DB_CACHE_TTL_MS: config.cacheTtlMs,
+          VECTOR_DIMENSION: config.vectorDimension,
+          VECTOR_MIN_SIMILARITY: config.vectorMinSimilarity,
+        }),
+        reason: 'Explicit PostgreSQL configuration',
+      };
+    }
+    return {
+      type: 'sqlite',
+      sqlitePath: config.sqlitePath ?? getDefaultSqlitePath(),
+      reason: 'Explicit SQLite configuration',
+    };
+  }
+
+  // 2. Check for DATABASE_URL (usually means PostgreSQL is intended)
+  if (config.postgresUrl) {
+    return {
+      type: 'postgresql',
+      connectionString: config.postgresUrl,
+      reason: 'DATABASE_URL environment variable set',
+    };
+  }
+
+  // 3. Try PostgreSQL connection
+  try {
+    const connectionString = buildPostgresUrl({
+      DATABASE_URL: config.postgresUrl,
+      DB_HOST: config.postgresHost,
+      DB_PORT: config.postgresPort,
+      DB_USER: config.postgresUser,
+      DB_PASSWORD: config.postgresPassword,
+      DB_NAME: config.postgresDatabase,
+      DB_POOL_MAX: config.postgresPoolMax,
+      DB_POOL_IDLE_TIMEOUT_MS: config.postgresIdleTimeoutMs,
+      DB_POOL_CONNECTION_TIMEOUT_MS: config.postgresConnectionTimeoutMs,
+      DATABASE_TYPE: 'auto',
+      SQLITE_PATH: config.sqlitePath,
+      DB_HEALTH_CHECK_INTERVAL_MS: config.healthCheckIntervalMs,
+      DB_CIRCUIT_BREAKER_THRESHOLD: config.circuitBreakerThreshold,
+      DB_CIRCUIT_BREAKER_TIMEOUT_MS: config.circuitBreakerTimeoutMs,
+      DB_CACHE_MAX_SIZE: config.cacheMaxSize,
+      DB_CACHE_TTL_MS: config.cacheTtlMs,
+      VECTOR_DIMENSION: config.vectorDimension,
+      VECTOR_MIN_SIMILARITY: config.vectorMinSimilarity,
+    });
+
+    const pool = new Pool({
+      connectionString,
+      connectionTimeoutMillis: 3000, // Quick timeout for detection
+    });
+
+    try {
+      const client = await pool.connect();
+      await client.query('SELECT 1');
+      client.release();
+      await pool.end();
+
+      logger.info('PostgreSQL connection successful');
+      return {
+        type: 'postgresql',
+        connectionString,
+        reason: 'PostgreSQL connection successful',
+      };
+    } finally {
+      await pool.end().catch(() => {});
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Unknown error';
+    logger.debug('PostgreSQL not available, falling back to SQLite', { error: message });
+  }
+
+  // 4. Fall back to SQLite
+  const sqlitePath = config.sqlitePath ?? getDefaultSqlitePath();
+  return {
+    type: 'sqlite',
+    sqlitePath,
+    reason: 'PostgreSQL unavailable, using SQLite fallback',
+  };
+}
+
+/**
+ * Create database adapter based on detection result
+ */
+export async function createAdapter(detection: DetectionResult, config: DatabaseConfig): Promise<DatabaseAdapter> {
+  let adapter: DatabaseAdapter;
+
+  if (detection.type === 'postgresql') {
+    adapter = new PostgresAdapter(detection.connectionString!, config);
+  } else {
+    adapter = new SQLiteAdapter(detection.sqlitePath!, config);
+  }
+
+  await adapter.initialize();
+  return adapter;
+}
+
+/**
+ * Get or create the database adapter singleton
+ */
+export async function getAdapter(): Promise<DatabaseAdapter> {
+  if (adapterInstance?.isInitialized) {
+    return adapterInstance;
+  }
+
+  if (!initPromise) {
+    initPromise = initializeAdapter();
+  }
+
+  return initPromise;
+}
+
+/**
+ * Initialize the database adapter
+ */
+async function initializeAdapter(): Promise<DatabaseAdapter> {
+  const config = getDatabaseConfig();
+  const detection = await detectDatabase(config);
+
+  logger.info('Database detected', {
+    type: detection.type,
+    reason: detection.reason,
+    path: detection.sqlitePath,
+  });
+
+  adapterInstance = await createAdapter(detection, config);
+  return adapterInstance;
+}
+
+/**
+ * Close the database adapter
+ */
+export async function closeAdapter(): Promise<void> {
+  if (adapterInstance) {
+    await adapterInstance.close();
+    adapterInstance = null;
+    initPromise = null;
+    logger.info('Database adapter closed');
+  }
+}
+
+/**
+ * Reset adapter (for testing)
+ */
+export function resetAdapter(): void {
+  adapterInstance = null;
+  initPromise = null;
+}
+
+/**
+ * Check if adapter is initialized
+ */
+export function isAdapterInitialized(): boolean {
+  return adapterInstance?.isInitialized ?? false;
+}
+
+/**
+ * Get current adapter type
+ */
+export function getAdapterType(): 'postgresql' | 'sqlite' | null {
+  return adapterInstance?.type ?? null;
+}
+
+// Re-export adapter classes
+export { PostgresAdapter } from './postgres-adapter.js';
+export { SQLiteAdapter } from './sqlite-adapter.js';
+export { BaseAdapter } from './base-adapter.js';
+
+export default {
+  getAdapter,
+  closeAdapter,
+  resetAdapter,
+  detectDatabase,
+  createAdapter,
+  isAdapterInitialized,
+  getAdapterType,
+};

package/src/database/adapters/postgres-adapter.ts

@@ -0,0 +1,285 @@
+/**
+ * PostgreSQL Database Adapter
+ *
+ * Adapter for PostgreSQL with connection pooling and pgvector support.
+ */
+
+import pg from 'pg';
+import type { QueryResultRow } from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import { sql } from 'drizzle-orm';
+
+import { BaseAdapter } from './base-adapter.js';
+import type {
+  QueryResult,
+  TransactionClient,
+  PoolStats,
+  DatabaseConfig,
+} from '../types.js';
+import { createLogger } from '../../utils/logger.js';
+import { MemoryError } from '../../utils/errors.js';
+
+import * as schema from '../drizzle/schema/index.js';
+
+const { Pool } = pg;
+const logger = createLogger('PostgresAdapter');
+
+/**
+ * PostgreSQL database adapter with Drizzle ORM
+ */
+export class PostgresAdapter extends BaseAdapter {
+  readonly type = 'postgresql' as const;
+
+  private pool: pg.Pool | null = null;
+  private drizzleInstance: NodePgDatabase<typeof schema> | null = null;
+  private connectionString: string;
+  private config: DatabaseConfig;
+
+  constructor(connectionString: string, config: DatabaseConfig) {
+    super();
+    this.connectionString = connectionString;
+    this.config = config;
+  }
+
+  /**
+   * Get Drizzle ORM instance
+   */
+  get drizzle(): NodePgDatabase<typeof schema> {
+    this.ensureInitialized();
+    return this.drizzleInstance!;
+  }
+
+  /**
+   * Get raw pool (for advanced operations)
+   */
+  get rawPool(): pg.Pool {
+    this.ensureInitialized();
+    return this.pool!;
+  }
+
+  /**
+   * Initialize PostgreSQL connection pool
+   */
+  async initialize(): Promise<void> {
+    if (this._isInitialized) return;
+
+    try {
+      this.pool = new Pool({
+        connectionString: this.connectionString,
+        max: this.config.postgresPoolMax,
+        idleTimeoutMillis: this.config.postgresIdleTimeoutMs,
+        connectionTimeoutMillis: this.config.postgresConnectionTimeoutMs,
+      });
+
+      // Set up event handlers
+      this.pool.on('error', (err) => {
+        logger.error('Pool error', { error: err.message });
+      });
+
+      this.pool.on('connect', () => {
+        logger.debug('New client connected to pool');
+      });
+
+      // Create Drizzle instance
+      this.drizzleInstance = drizzle(this.pool, {
+        schema,
+        logger: process.env.NODE_ENV === 'development',
+      });
+
+      // Test connection and enable pgvector
+      await this.testConnection();
+      await this.enablePgVector();
+
+      this._isInitialized = true;
+      logger.info('PostgreSQL adapter initialized', {
+        host: this.config.postgresHost,
+        database: this.config.postgresDatabase,
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      logger.error('Failed to initialize PostgreSQL', { error: message });
+      throw new MemoryError(`PostgreSQL initialization failed: ${message}`);
+    }
+  }
+
+  /**
+   * Test database connection
+   */
+  private async testConnection(): Promise<void> {
+    const client = await this.pool!.connect();
+    try {
+      await client.query('SELECT 1');
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Enable pgvector extension if not already enabled
+   */
+  private async enablePgVector(): Promise<void> {
+    try {
+      await this.pool!.query('CREATE EXTENSION IF NOT EXISTS vector');
+      logger.debug('pgvector extension enabled');
+    } catch (error) {
+      logger.warn('Could not enable pgvector extension', {
+        error: error instanceof Error ? error.message : 'Unknown'
+      });
+      // Don't fail - extension might already exist or user might not have permissions
+    }
+  }
+
+  /**
+   * Execute a raw SQL query
+   */
+  async query<T extends QueryResultRow = Record<string, any>>(
+    sqlText: string,
+    params?: unknown[]
+  ): Promise<QueryResult<T>> {
+    this.ensureInitialized();
+    const start = Date.now();
+
+    try {
+      const result = await this.pool!.query<T>(sqlText, params);
+      const duration = Date.now() - start;
+      this.logQuery(sqlText, duration, result.rowCount);
+
+      return {
+        rows: result.rows,
+        rowCount: result.rowCount,
+      };
+    } catch (error) {
+      this.logError(sqlText, error);
+      const message = error instanceof Error ? error.message : 'Unknown error';
+      throw new MemoryError(`Query failed: ${message}`);
+    }
+  }
+
+  /**
+   * Execute a transaction
+   */
+  async transaction<T>(
+    callback: (client: TransactionClient) => Promise<T>
+  ): Promise<T> {
+    this.ensureInitialized();
+    const client = await this.pool!.connect();
+
+    try {
+      await client.query('BEGIN');
+
+      const transactionClient: TransactionClient = {
+        query: async <R extends QueryResultRow = Record<string, any>>(
+          sqlText: string,
+          params?: unknown[]
+        ): Promise<QueryResult<R>> => {
+          const result = await client.query<R>(sqlText, params);
+          return {
+            rows: result.rows,
+            rowCount: result.rowCount,
+          };
+        },
+      };
+
+      const result = await callback(transactionClient);
+      await client.query('COMMIT');
+      return result;
+    } catch (error) {
+      await client.query('ROLLBACK');
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+
+  /**
+   * Check database health
+   */
+  async healthCheck(): Promise<boolean> {
+    try {
+      const result = await this.query<{ ok: number }>('SELECT 1 as ok');
+      return result.rows.length > 0 && result.rows[0]!.ok === 1;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Get connection pool statistics
+   */
+  getPoolStats(): PoolStats {
+    if (!this.pool) {
+      return { total: 0, idle: 0, waiting: 0 };
+    }
+
+    return {
+      total: this.pool.totalCount,
+      idle: this.pool.idleCount,
+      waiting: this.pool.waitingCount,
+    };
+  }
+
+  /**
+   * Close all connections
+   */
+  async close(): Promise<void> {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+      this.drizzleInstance = null;
+      this._isInitialized = false;
+      logger.info('PostgreSQL pool closed');
+    }
+  }
+
+  /**
+   * Execute vector similarity search
+   */
+  async vectorSearch<T = Record<string, unknown>>(
+    table: string,
+    embeddingColumn: string,
+    queryEmbedding: number[],
+    options: {
+      limit?: number;
+      minSimilarity?: number;
+      filters?: Record<string, unknown>;
+      selectColumns?: string[];
+    } = {}
+  ): Promise<Array<T & { similarity: number }>> {
+    const {
+      limit = 5,
+      minSimilarity = 0.7,
+      filters = {},
+      selectColumns = ['*'],
+    } = options;
+
+    const embeddingStr = `[${queryEmbedding.join(',')}]`;
+
+    // Build WHERE clause
+    const whereConditions = [`1 - (${embeddingColumn} <=> $1::vector) >= $2`];
+    const params: unknown[] = [embeddingStr, minSimilarity];
+    let paramIndex = 3;
+
+    for (const [key, value] of Object.entries(filters)) {
+      whereConditions.push(`${key} = $${paramIndex}`);
+      params.push(value);
+      paramIndex++;
+    }
+
+    params.push(limit);
+
+    const columns = selectColumns.join(', ');
+    const sql = `
+      SELECT ${columns}, 1 - (${embeddingColumn} <=> $1::vector) as similarity
+      FROM ${table}
+      WHERE ${whereConditions.join(' AND ')}
+      ORDER BY similarity DESC
+      LIMIT $${paramIndex}
+    `;
+
+    const result = await this.query<T & { similarity: number }>(sql, params);
+    return result.rows;
+  }
+}
+
+export default PostgresAdapter;