feat(database): enhance database initialization and migration handling with improved logging and test coverage

Author: Lasim

services/backend/src/db/index.ts

@@ -151,18 +151,21 @@ async function createDatabaseInstance(config: DatabaseConfig, schema: AnySchema,
  * Apply migrations for any database type
  */
 async function applyMigrations(db: AnyDatabase, config: DatabaseConfig, logger: FastifyBaseLogger) {
+  // Skip migrations in test mode
+  if (isTestMode()) {
+    return;
+  }
+
   const projectRootMigrationsDir = path.join(process.cwd(), 'drizzle');
   const migrationsPath = path.join(projectRootMigrationsDir, 'migrations_sqlite');
 
   try {
     await fs.access(migrationsPath);
   } catch {
-    if (!isTestMode()) {
-      logger.info({
-        operation: 'apply_migrations',
-        migrationsPath
-      }, `Migrations directory not found at: ${migrationsPath}, skipping migrations.`);
-    }
+    logger.info({
+      operation: 'apply_migrations',
+      migrationsPath
+    }, `Migrations directory not found at: ${migrationsPath}, skipping migrations.`);
     return;
   }
 
@@ -369,11 +372,9 @@ async function applyMigrations(db: AnyDatabase, config: DatabaseConfig, logger:
  */
 export async function initializeDatabase(logger: FastifyBaseLogger): Promise<boolean> {
   if (isDbInitialized) {
-    if (!isTestMode()) {
-      logger.info({
-        operation: 'initialize_database'
-      }, 'Database already initialized.');
-    }
+    logger.info({
+      operation: 'initialize_database'
+    }, 'Database already initialized.');
     return true;
   }
 
@@ -419,11 +420,9 @@ export async function initializeDatabase(logger: FastifyBaseLogger): Promise<boo
   } catch (error) {
     const typedError = error as Error;
     if (typedError.message.includes('No database selection found')) {
-      if (!isTestMode()) {
-        logger.info({
-          operation: 'initialize_database'
-        }, 'No database configured yet. Please use the /api/db/setup endpoint to configure your database.');
-      }
+      logger.info({
+        operation: 'initialize_database'
+      }, 'No database configured yet. Please use the /api/db/setup endpoint to configure your database.');
     } else {
       logger.error({
         operation: 'initialize_database',
@@ -459,21 +458,53 @@ export function getSchema(): AnySchema {
  * Get database status
  */
 export function getDbStatus() {
-  if (!dbConfig) {
+  try {
+    if (!dbConfig) {
+      // Try to get config to see if one exists
+      const config = getDatabaseConfig();
+      if (config) {
+        return {
+          configured: validateDatabaseConfig(config),
+          initialized: isDbInitialized,
+          dialect: config.type,
+          type: config.type
+        };
+      }
+    }
+    
+    if (!dbConfig) {
+      return {
+        configured: false,
+        initialized: false,
+        dialect: null,
+        type: null
+      };
+    }
+    
+    return {
+      configured: validateDatabaseConfig(dbConfig),
+      initialized: isDbInitialized,
+      dialect: dbConfig.type,
+      type: dbConfig.type
+    };
+  } catch {
     return {
       configured: false,
       initialized: false,
       dialect: null,
       type: null
     };
   }
-  
-  return {
-    configured: validateDatabaseConfig(dbConfig),
-    initialized: isDbInitialized,
-    dialect: dbConfig.type,
-    type: dbConfig.type
-  };
+}
+
+/**
+ * Reset database state (for testing)
+ */
+export function resetDatabaseState() {
+  dbInstance = null;
+  dbSchema = null;
+  dbConfig = null;
+  isDbInitialized = false;
 }
 
 /**
@@ -492,7 +523,7 @@ export function executeDbOperation<T>(
 interface DatabaseExtensionWithTables extends DatabaseExtension {
 
   tableDefinitions?: Record<string, Record<string, (columnBuilder: any) => any>>;
-  onDatabaseInit?: (db: AnyDatabase, logger: FastifyBaseLogger) => Promise<void>;
+  onDatabaseInit?: (db: AnyDatabase, schema: AnySchema) => Promise<void>;
 }
 
 export function registerPluginTables(plugins: Plugin[], logger?: FastifyBaseLogger) {
@@ -515,11 +546,9 @@ export function registerPluginTables(plugins: Plugin[], logger?: FastifyBaseLogg
 }
 
 export async function createPluginTables(plugins: Plugin[], logger: FastifyBaseLogger) {
-  if (!isTestMode()) {
-    logger.info({
-      operation: 'create_plugin_tables'
-    }, 'Plugin tables are handled by migrations.');
-  }
+  logger.info({
+    operation: 'create_plugin_tables'
+  }, 'Plugin tables are handled by migrations.');
 }
 
 export async function initializePluginDatabases(db: AnyDatabase, plugins: Plugin[], logger: FastifyBaseLogger) {
@@ -535,7 +564,15 @@ export async function initializePluginDatabases(db: AnyDatabase, plugins: Plugin
       try {
         // Create a child logger for this plugin
         const pluginLogger = logger.child({ pluginId: plugin.meta.id });
-        await ext.onDatabaseInit(db, pluginLogger);
+        // Get the current schema - use dbSchema directly if available, otherwise generate one
+        let schema: AnySchema;
+        try {
+          schema = getSchema();
+        } catch {
+          // If getSchema fails, generate a basic schema for the plugin
+          schema = generateSchema();
+        }
+        await ext.onDatabaseInit(db, schema);
         if (!isTestMode()) {
           logger.info({
             operation: 'initialize_plugin_databases',

services/backend/tests/unit/db/config.test.ts

@@ -1,13 +1,33 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { validateDatabaseConfig, getDatabaseStatus } from '../../../src/db/config';
+import { validateDatabaseConfig, getDatabaseStatus, getDatabaseConfig } from '../../../src/db/config';
 import type { DatabaseConfig } from '../../../src/db/config';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Mock the fs module
+vi.mock('fs', () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+}));
+
+// Mock the path module
+vi.mock('path', () => ({
+  join: vi.fn((...paths) => paths.join('/')),
+}));
+
+// Mock process.cwd
+const originalCwd = process.cwd;
+
+const mockedFs = vi.mocked(fs);
+const mockedPath = vi.mocked(path);
 
 describe('Database Configuration', () => {
   let originalEnv: string | undefined;
   let originalDbType: string | undefined;
   let originalSqliteDbPath: string | undefined;
   let originalTursoUrl: string | undefined;
   let originalTursoToken: string | undefined;
+  let mockLogger: any;
 
   beforeEach(() => {
     // Store original environment variables
@@ -22,6 +42,26 @@ describe('Database Configuration', () => {
     delete process.env.SQLITE_DB_PATH;
     delete process.env.TURSO_DATABASE_URL;
     delete process.env.TURSO_AUTH_TOKEN;
+    
+    // Create mock logger
+    mockLogger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+    
+    // Reset mocks
+    vi.clearAllMocks();
+    
+    // Default mock implementations
+    mockedFs.existsSync.mockReturnValue(false);
+    mockedFs.readFileSync.mockReturnValue('');
+    
+    // Mock path.join
+    mockedPath.join.mockImplementation((...paths) => paths.join('/'));
+    
+    // Mock process.cwd
+    process.cwd = vi.fn(() => '/mock/cwd');
   });
 
   afterEach(() => {
@@ -49,6 +89,9 @@ describe('Database Configuration', () => {
     } else {
       delete process.env.TURSO_AUTH_TOKEN;
     }
+    
+    // Restore process.cwd
+    process.cwd = originalCwd;
   });
 
   describe('validateDatabaseConfig', () => {
@@ -371,4 +414,79 @@ describe('Database Configuration', () => {
       expect(result).toBe(false);
     });
   });
+
+  describe('Integration scenarios', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should handle complete SQLite workflow', () => {
+      // Simulate no selection file, use environment
+      mockedFs.existsSync.mockReturnValue(false);
+      process.env.NODE_ENV = 'production'; // Override test mode
+      process.env.DB_TYPE = 'sqlite';
+      process.env.SQLITE_DB_PATH = '/production/path/database.db';
+
+      const config = getDatabaseConfig(mockLogger);
+      const isValid = validateDatabaseConfig(config);
+      const status = getDatabaseStatus(config);
+
+      expect(config).toEqual({
+        type: 'sqlite',
+        dbPath: '/production/path/database.db'
+      });
+      expect(isValid).toBe(true);
+      expect(status).toEqual({
+        configured: true,
+        dialect: 'sqlite',
+        type: 'sqlite'
+      });
+    });
+
+    it('should handle fallback scenario with partial configuration', () => {
+      // Simulate corrupted selection file, fallback to environment
+      mockedFs.existsSync.mockReturnValue(true);
+      mockedFs.readFileSync.mockImplementation(() => {
+        throw new Error('File corrupted');
+      });
+      
+      process.env.NODE_ENV = 'production'; // Override test mode
+      process.env.DB_TYPE = 'turso';
+      process.env.TURSO_DATABASE_URL = 'libsql://fallback.turso.io';
+      // Missing auth token - should throw error
+
+      expect(() => getDatabaseConfig(mockLogger)).toThrow(
+        'Turso configuration incomplete. Required: TURSO_DATABASE_URL, TURSO_AUTH_TOKEN'
+      );
+    });
+  });
+
+  describe('Performance and reliability', () => {
+    it('should handle file system race conditions', () => {
+      process.env.NODE_ENV = 'production'; // Override test mode
+      let callCount = 0;
+      mockedFs.existsSync.mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return true; // First call says file exists
+        }
+        return false; // Subsequent calls say it doesn't (race condition)
+      });
+      
+      mockedFs.readFileSync.mockImplementation(() => {
+        throw new Error('File disappeared');
+      });
+      
+      process.env.DB_TYPE = 'sqlite';
+
+      const config = getDatabaseConfig(mockLogger);
+      
+      expect(config.type).toBe('sqlite');
+      expect(config.dbPath).toBe('persistent_data/database/deploystack.db');
+    });
+  });
 });