4runr-os 2.10.9 → 2.10.13

package/apps/gateway/src/db/init.ts

@@ -1,289 +1,299 @@
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-import { PrismaClient } from '@prisma/client';
-import { get4RunrDataDir } from '@4runr/shared';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import {
-  isDockerAvailable,
-  isDockerRunning,
-  areContainersRunning,
-  startDockerCompose,
-  waitForHealthy,
-  getDockerStatus
-} from './docker-manager.js';
-
-/**
- * Database initialization result
- */
-export interface DatabaseInitResult {
-  mode: 'docker' | 'memory';
-  client: PrismaClient | null;
-  databaseUrl?: string;
-  error?: string;
-  warnings?: string[];
-}
-
-/**
- * Initialize database for Gateway
- * Handles Docker auto-start, migrations, and fallback to memory mode
- * 
- * @param logger - Fastify logger or compatible logger
- */
-export async function initializeDatabase(logger: any): Promise<DatabaseInitResult> {
-  const warnings: string[] = [];
-  
-  // Check explicit memory mode
-  const persistenceMode = process.env['GATEWAY_PERSISTENCE'] || 'auto';
-  if (persistenceMode === 'memory') {
-    logger.info('GATEWAY_PERSISTENCE=memory - skipping database initialization');
-    return { mode: 'memory', client: null };
-  }
-  
-  // Check if DATABASE_URL is explicitly provided (e.g., production)
-  if (process.env['DATABASE_URL'] && persistenceMode === 'postgres') {
-    logger.info('Using explicitly configured DATABASE_URL');
-    return await initializeWithExistingDatabase(logger);
-  }
-  
-  // Auto mode: Try Docker-based local database
-  logger.info('Checking Docker availability for local database...');
-  
-  const dockerStatus = await getDockerStatus();
-  
-  if (!dockerStatus.available) {
-    logger.warn('⚠️  Docker not available. Falling back to memory-only mode.');
-    warnings.push('Docker not installed - install Docker Desktop to enable persistent storage');
-    return { mode: 'memory', client: null, warnings };
-  }
-  
-  if (!dockerStatus.running) {
-    logger.warn('⚠️  Docker daemon not running. Falling back to memory-only mode.');
-    warnings.push('Docker is installed but not running - start Docker Desktop to enable persistent storage');
-    return { mode: 'memory', client: null, warnings };
-  }
-  
-  // Docker is available - proceed with container startup
-  try {
-    const containersRunning = await areContainersRunning();
-    
-    if (!containersRunning) {
-      logger.info('Starting 4Runr Docker containers...');
-      await startDockerContainers(logger);
-      logger.info('✓ Docker containers started');
-    } else {
-      logger.info('✓ Docker containers already running');
-    }
-    
-    // Wait for containers to be healthy
-    logger.info('Waiting for database to be ready...');
-    await waitForHealthy('4runr-postgres', 60000); // 60s for Postgres (first start slower)
-    await waitForHealthy('4runr-redis', 15000);
-    logger.info('✓ Database containers healthy');
-    
-    // Build DATABASE_URL and REDIS_URL for local Docker setup (localhost not 'postgres' hostname)
-    const databaseUrl = 'postgresql://4runr:4runr_dev_pass@localhost:5432/4runr_local';
-    const redisUrl = 'redis://localhost:6379';
-    
-    // Set environment variables so Redis client can connect when first requested
-    process.env['DATABASE_URL'] = databaseUrl;
-    process.env['REDIS_URL'] = redisUrl;
-    
-    // Run migrations
-    logger.info('Running database migrations...');
-    await runMigrations(databaseUrl, logger);
-    logger.info('✓ Migrations complete');
-    
-    // Create Prisma client
-    const client = new PrismaClient({
-      datasources: {
-        db: {
-          url: databaseUrl
-        }
-      },
-      log: [
-        { level: 'warn', emit: 'event' },
-        { level: 'error', emit: 'event' }
-      ]
-    });
-    
-    // Wire up Prisma logs to Fastify logger
-    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
-    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
-    
-    // Test connection
-    await client.$connect();
-    logger.info('✓ Database connection established');
-    
-    return {
-      mode: 'docker',
-      client,
-      databaseUrl
-    };
-    
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    logger.error({ err }, 'Failed to initialize Docker database');
-    logger.warn('⚠️  Falling back to memory-only mode');
-    
-    return {
-      mode: 'memory',
-      client: null,
-      error: errorMsg,
-      warnings: ['Database initialization failed - running in memory-only mode', errorMsg]
-    };
-  }
-}
-
-/**
- * Initialize with an existing database (production mode)
- */
-async function initializeWithExistingDatabase(logger: any): Promise<DatabaseInitResult> {
-  try {
-    const databaseUrl = process.env['DATABASE_URL']!;
-    
-    // Run migrations
-    logger.info('Running database migrations...');
-    await runMigrations(databaseUrl, logger);
-    logger.info('✓ Migrations complete');
-    
-    // Create Prisma client
-    const client = new PrismaClient({
-      log: [
-        { level: 'warn', emit: 'event' },
-        { level: 'error', emit: 'event' }
-      ]
-    });
-    
-    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
-    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
-    
-    await client.$connect();
-    logger.info('✓ Database connection established');
-    
-    return {
-      mode: 'docker', // Could be 'postgres' but we use 'docker' as generic DB mode
-      client,
-      databaseUrl
-    };
-    
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    logger.error({ err }, 'Failed to connect to database');
-    
-    return {
-      mode: 'memory',
-      client: null,
-      error: errorMsg,
-      warnings: ['Database connection failed - running in memory-only mode', errorMsg]
-    };
-  }
-}
-
-/**
- * Start Docker containers
- */
-async function startDockerContainers(logger: any): Promise<void> {
-  // Get user data directory
-  const dataDir = get4RunrDataDir();
-  const composeFilePath = path.join(dataDir, 'docker-compose.yml');
-  
-  // Copy docker-compose template if not exists
-  if (!fs.existsSync(composeFilePath)) {
-    // Try multiple possible template locations
-    const possiblePaths = [
-      path.join(__dirname, '../../docker-compose.local.yml'),  // dist/apps/gateway/src/db -> apps/gateway
-      path.join(__dirname, '../../../docker-compose.local.yml'),  // nested build output
-      path.join(__dirname, '../../../../docker-compose.local.yml'),  // even more nested
-      path.join(process.cwd(), 'apps/gateway/docker-compose.local.yml'),  // from repo root
-      path.join(process.cwd(), 'docker-compose.local.yml'),  // vendored in os-cli
-    ];
-    
-    let templatePath: string | null = null;
-    for (const tryPath of possiblePaths) {
-      if (fs.existsSync(tryPath)) {
-        templatePath = tryPath;
-        logger.info(`Found Docker Compose template at ${tryPath}`);
-        break;
-      }
-    }
-    
-    if (!templatePath) {
-      throw new Error(`Docker Compose template not found. Tried: ${possiblePaths.join(', ')}`);
-    }
-    
-    logger.info(`Copying Docker Compose template to ${composeFilePath}`);
-    fs.copyFileSync(templatePath, composeFilePath);
-  }
-  
-  // Start containers
-  await startDockerCompose(composeFilePath);
-}
-
-/**
- * Run Prisma migrations
- */
-async function runMigrations(databaseUrl: string, logger: any): Promise<void> {
-  // dist/src/db -> monorepo root: ../../../../../prisma. Also support global 4runr-os (cwd often apps/gateway).
-  const candidates = [
-    path.join(process.cwd(), '..', '..', 'prisma', 'schema.prisma'),
-    path.join(__dirname, '../../../../../prisma/schema.prisma'),
-    path.join(__dirname, '../../../../prisma/schema.prisma'),
-    path.join(__dirname, '../../../prisma/schema.prisma'),
-    path.join(process.cwd(), 'prisma', 'schema.prisma'),
-  ];
-  let actualSchemaPath: string | null = null;
-  for (const p of candidates) {
-    if (fs.existsSync(p)) {
-      actualSchemaPath = p;
-      break;
-    }
-  }
-  if (!actualSchemaPath) {
-    logger.warn(
-      `⚠️  Prisma schema not found (tried ${candidates.length} locations relative to Gateway), skipping migrations`,
-    );
-    return;
-  }
-  
-  try {
-    // For local Docker Postgres, use db push to avoid migration compatibility
-    // (migrations were created for SQLite, need Postgres-native approach)
-    const isLocalDocker = databaseUrl.includes('localhost:5432');
-    const command = isLocalDocker 
-      ? `npx prisma db push --skip-generate --accept-data-loss`
-      : `npx prisma migrate deploy`;
-    
-    execSync(command, {
-      env: {
-        ...process.env,
-        DATABASE_URL: databaseUrl
-      },
-      cwd: path.dirname(actualSchemaPath),
-      stdio: 'pipe', // Suppress output unless error
-      timeout: 60000 // 60 seconds
-    });
-  } catch (err) {
-    const errorMsg = err instanceof Error ? err.message : String(err);
-    logger.error(`Migration failed: ${errorMsg}`);
-    throw new Error(`Database migration failed: ${errorMsg}`);
-  }
-}
-
-/**
- * Cleanup function for graceful shutdown
- */
-export async function shutdownDatabase(client: PrismaClient | null, logger: any): Promise<void> {
-  if (client) {
-    try {
-      await client.$disconnect();
-      logger.info('✓ Database connection closed');
-    } catch (err) {
-      logger.error({ err }, 'Error disconnecting from database');
-    }
-  }
-}
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { PrismaClient } from '@prisma/client';
+import { get4RunrDataDir } from '@4runr/shared';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+import {
+  isDockerAvailable,
+  isDockerRunning,
+  areContainersRunning,
+  startDockerCompose,
+  waitForHealthy,
+  getDockerStatus
+} from './docker-manager.js';
+
+/**
+ * Database initialization result
+ */
+export interface DatabaseInitResult {
+  mode: 'docker' | 'memory';
+  client: PrismaClient | null;
+  databaseUrl?: string;
+  error?: string;
+  warnings?: string[];
+}
+
+/**
+ * Initialize database for Gateway
+ * Handles Docker auto-start, migrations, and fallback to memory mode
+ * 
+ * @param logger - Fastify logger or compatible logger
+ */
+export async function initializeDatabase(logger: any): Promise<DatabaseInitResult> {
+  const warnings: string[] = [];
+  
+  // Check explicit memory mode
+  const persistenceMode = process.env['GATEWAY_PERSISTENCE'] || 'auto';
+  if (persistenceMode === 'memory') {
+    logger.info('GATEWAY_PERSISTENCE=memory - skipping database initialization');
+    return { mode: 'memory', client: null };
+  }
+  
+  // Check if DATABASE_URL is explicitly provided (e.g., production)
+  if (process.env['DATABASE_URL'] && persistenceMode === 'postgres') {
+    logger.info('Using explicitly configured DATABASE_URL');
+    return await initializeWithExistingDatabase(logger);
+  }
+  
+  // Auto mode: Try Docker-based local database
+  logger.info('Checking Docker availability for local database...');
+  
+  const dockerStatus = await getDockerStatus();
+  
+  if (!dockerStatus.available) {
+    logger.warn('⚠️  Docker not available. Falling back to memory-only mode.');
+    warnings.push('Docker not installed - install Docker Desktop to enable persistent storage');
+    return { mode: 'memory', client: null, warnings };
+  }
+  
+  if (!dockerStatus.running) {
+    logger.warn('⚠️  Docker daemon not running. Falling back to memory-only mode.');
+    warnings.push('Docker is installed but not running - start Docker Desktop to enable persistent storage');
+    return { mode: 'memory', client: null, warnings };
+  }
+  
+  // Docker is available - proceed with container startup
+  try {
+    const containersRunning = await areContainersRunning();
+    
+    if (!containersRunning) {
+      logger.info('Starting 4Runr Docker containers...');
+      await startDockerContainers(logger);
+      logger.info('✓ Docker containers started');
+    } else {
+      logger.info('✓ Docker containers already running');
+    }
+    
+    // Wait for containers to be healthy
+    logger.info('Waiting for database to be ready...');
+    await waitForHealthy('4runr-postgres', 60000); // 60s for Postgres (first start slower)
+    await waitForHealthy('4runr-redis', 15000);
+    logger.info('✓ Database containers healthy');
+    
+    // Build DATABASE_URL and REDIS_URL for local Docker setup (localhost not 'postgres' hostname)
+    const databaseUrl = 'postgresql://4runr:4runr_dev_pass@localhost:5432/4runr_local';
+    const redisUrl = 'redis://localhost:6379';
+    
+    // Set environment variables so Redis client can connect when first requested
+    process.env['DATABASE_URL'] = databaseUrl;
+    process.env['REDIS_URL'] = redisUrl;
+    
+    // Run migrations
+    logger.info('Running database migrations...');
+    await runMigrations(databaseUrl, logger);
+    logger.info('✓ Migrations complete');
+    
+    // Create Prisma client
+    const client = new PrismaClient({
+      datasources: {
+        db: {
+          url: databaseUrl
+        }
+      },
+      log: [
+        { level: 'warn', emit: 'event' },
+        { level: 'error', emit: 'event' }
+      ]
+    });
+    
+    // Wire up Prisma logs to Fastify logger
+    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
+    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
+    
+    // Test connection
+    await client.$connect();
+    logger.info('✓ Database connection established');
+    
+    return {
+      mode: 'docker',
+      client,
+      databaseUrl
+    };
+    
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error({ err }, 'Failed to initialize Docker database');
+    logger.warn('⚠️  Falling back to memory-only mode');
+    
+    return {
+      mode: 'memory',
+      client: null,
+      error: errorMsg,
+      warnings: ['Database initialization failed - running in memory-only mode', errorMsg]
+    };
+  }
+}
+
+/**
+ * Initialize with an existing database (production mode)
+ */
+async function initializeWithExistingDatabase(logger: any): Promise<DatabaseInitResult> {
+  try {
+    const databaseUrl = process.env['DATABASE_URL']!;
+    
+    // Run migrations
+    logger.info('Running database migrations...');
+    await runMigrations(databaseUrl, logger);
+    logger.info('✓ Migrations complete');
+    
+    // Create Prisma client
+    const client = new PrismaClient({
+      log: [
+        { level: 'warn', emit: 'event' },
+        { level: 'error', emit: 'event' }
+      ]
+    });
+    
+    client.$on('warn', (e: any) => logger.warn({ prisma: true }, e.message));
+    client.$on('error', (e: any) => logger.error({ prisma: true }, e.message));
+    
+    await client.$connect();
+    logger.info('✓ Database connection established');
+    
+    return {
+      mode: 'docker', // Could be 'postgres' but we use 'docker' as generic DB mode
+      client,
+      databaseUrl
+    };
+    
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error({ err }, 'Failed to connect to database');
+    
+    return {
+      mode: 'memory',
+      client: null,
+      error: errorMsg,
+      warnings: ['Database connection failed - running in memory-only mode', errorMsg]
+    };
+  }
+}
+
+/**
+ * Start Docker containers
+ */
+async function startDockerContainers(logger: any): Promise<void> {
+  // Get user data directory
+  const dataDir = get4RunrDataDir();
+  const composeFilePath = path.join(dataDir, 'docker-compose.yml');
+  
+  // Copy docker-compose template if not exists
+  if (!fs.existsSync(composeFilePath)) {
+    // Try multiple possible template locations
+    const possiblePaths = [
+      path.join(__dirname, '../../docker-compose.local.yml'),  // dist/apps/gateway/src/db -> apps/gateway
+      path.join(__dirname, '../../../docker-compose.local.yml'),  // nested build output
+      path.join(__dirname, '../../../../docker-compose.local.yml'),  // even more nested
+      path.join(process.cwd(), 'apps/gateway/docker-compose.local.yml'),  // from repo root
+      path.join(process.cwd(), 'docker-compose.local.yml'),  // vendored in os-cli
+    ];
+    
+    let templatePath: string | null = null;
+    for (const tryPath of possiblePaths) {
+      if (fs.existsSync(tryPath)) {
+        templatePath = tryPath;
+        logger.info(`Found Docker Compose template at ${tryPath}`);
+        break;
+      }
+    }
+    
+    if (!templatePath) {
+      throw new Error(`Docker Compose template not found. Tried: ${possiblePaths.join(', ')}`);
+    }
+    
+    logger.info(`Copying Docker Compose template to ${composeFilePath}`);
+    fs.copyFileSync(templatePath, composeFilePath);
+  }
+  
+  // Start containers
+  await startDockerCompose(composeFilePath);
+}
+
+/**
+ * Run Prisma migrations
+ */
+async function runMigrations(databaseUrl: string, logger: any): Promise<void> {
+  // dist/src/db -> monorepo root: ../../../../../prisma. Also support global 4runr-os (cwd often apps/gateway).
+  const candidates = [
+    path.join(process.cwd(), '..', '..', 'prisma', 'schema.prisma'),
+    path.join(__dirname, '../../../../../prisma/schema.prisma'),
+    path.join(__dirname, '../../../../prisma/schema.prisma'),
+    path.join(__dirname, '../../../prisma/schema.prisma'),
+    path.join(process.cwd(), 'prisma', 'schema.prisma'),
+  ];
+  let actualSchemaPath: string | null = null;
+  for (const p of candidates) {
+    if (fs.existsSync(p)) {
+      actualSchemaPath = p;
+      break;
+    }
+  }
+  if (!actualSchemaPath) {
+    logger.warn(
+      `⚠️  Prisma schema not found (tried ${candidates.length} locations relative to Gateway), skipping migrations`,
+    );
+    return;
+  }
+  
+  try {
+    // For local Docker Postgres, use db push to avoid migration compatibility
+    // (migrations were created for SQLite, need Postgres-native approach)
+    const isLocalDocker = databaseUrl.includes('localhost:5432');
+    const command = isLocalDocker 
+      ? `npx prisma db push --skip-generate --accept-data-loss`
+      : `npx prisma migrate deploy`;
+    
+    execSync(command, {
+      env: {
+        ...process.env,
+        DATABASE_URL: databaseUrl
+      },
+      cwd: path.dirname(actualSchemaPath),
+      stdio: 'pipe', // Suppress output unless error
+      timeout: 60000 // 60 seconds
+    });
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    logger.error(`Migration failed: ${errorMsg}`);
+    throw new Error(`Database migration failed: ${errorMsg}`);
+  }
+}
+
+/**
+ * Cleanup function for graceful shutdown
+ */
+export async function shutdownDatabase(client: PrismaClient | null, logger: any): Promise<void> {
+  if (client) {
+    try {
+      await client.$disconnect();
+      logger.info('✓ Database connection closed');
+    } catch (err) {
+      logger.error({ err }, 'Error disconnecting from database');
+    }
+  }
+  
+  // Stop Docker containers (preserves data volumes)
+  try {
+    const { stop4RunrContainers } = await import('./docker-manager.js');
+    await stop4RunrContainers();
+    logger.info('✓ Docker containers stopped (data preserved)');
+  } catch (err) {
+    // Ignore errors - containers might not be running or Docker unavailable
+    logger.debug('Could not stop Docker containers (may not be running)');
+  }
+}