crowd-funder-from-jason/src/db/sqlite/init.ts

/**
 * SQLite Database Initialization
 * 
 * This module handles database initialization, including:
 * - Database connection management
 * - Schema creation and migration
 * - Connection pooling and lifecycle
 * - Error handling and recovery
 */

import { Database, SQLite3 } from '@wa-sqlite/sql.js';
import { DATABASE_SCHEMA, SQLiteTable } from './types';
import { logger } from '../../utils/logger';

// ============================================================================
// Database Connection Management
// ============================================================================

export interface DatabaseConnection {
  db: Database;
  sqlite3: SQLite3;
  isOpen: boolean;
  lastUsed: number;
}

let connection: DatabaseConnection | null = null;
const CONNECTION_TIMEOUT = 5 * 60 * 1000; // 5 minutes

/**
 * Initialize the SQLite database connection
 */
export async function initDatabase(): Promise<DatabaseConnection> {
  if (connection?.isOpen) {
    connection.lastUsed = Date.now();
    return connection;
  }

  try {
    const sqlite3 = await import('@wa-sqlite/sql.js');
    const db = await sqlite3.open(':memory:'); // TODO: Configure storage location

    // Enable foreign keys
    await db.exec('PRAGMA foreign_keys = ON;');
    
    // Configure for better performance
    await db.exec(`
      PRAGMA journal_mode = WAL;
      PRAGMA synchronous = NORMAL;
      PRAGMA cache_size = -2000; -- Use 2MB of cache
    `);

    connection = {
      db,
      sqlite3,
      isOpen: true,
      lastUsed: Date.now()
    };

    // Start connection cleanup interval
    startConnectionCleanup();

    return connection;
  } catch (error) {
    logger.error('[SQLite] Database initialization failed:', error);
    throw new Error('Failed to initialize database');
  }
}

/**
 * Close the database connection
 */
export async function closeDatabase(): Promise<void> {
  if (!connection?.isOpen) return;

  try {
    await connection.db.close();
    connection.isOpen = false;
    connection = null;
  } catch (error) {
    logger.error('[SQLite] Database close failed:', error);
    throw new Error('Failed to close database');
  }
}

/**
 * Cleanup inactive connections
 */
function startConnectionCleanup(): void {
  setInterval(() => {
    if (connection && Date.now() - connection.lastUsed > CONNECTION_TIMEOUT) {
      closeDatabase().catch(error => {
        logger.error('[SQLite] Connection cleanup failed:', error);
      });
    }
  }, 60000); // Check every minute
}

// ============================================================================
// Schema Management
// ============================================================================

/**
 * Create the database schema
 */
export async function createSchema(): Promise<void> {
  const { db } = await initDatabase();

  try {
    await db.transaction(async () => {
      for (const table of DATABASE_SCHEMA) {
        await createTable(db, table);
      }
    });
  } catch (error) {
    logger.error('[SQLite] Schema creation failed:', error);
    throw new Error('Failed to create database schema');
  }
}

/**
 * Create a single table
 */
async function createTable(db: Database, table: SQLiteTable): Promise<void> {
  const columnDefs = table.columns.map(col => {
    const constraints = [
      col.primaryKey ? 'PRIMARY KEY' : '',
      col.unique ? 'UNIQUE' : '',
      !col.nullable ? 'NOT NULL' : '',
      col.references ? `REFERENCES ${col.references.table}(${col.references.column})` : '',
      col.default !== undefined ? `DEFAULT ${formatDefaultValue(col.default)}` : ''
    ].filter(Boolean).join(' ');

    return `${col.name} ${col.type} ${constraints}`.trim();
  });

  const createTableSQL = `
    CREATE TABLE IF NOT EXISTS ${table.name} (
      ${columnDefs.join(',\n      ')}
    );
  `;

  await db.exec(createTableSQL);

  // Create indexes
  if (table.indexes) {
    for (const index of table.indexes) {
      const createIndexSQL = `
        CREATE INDEX IF NOT EXISTS ${index.name} 
        ON ${table.name} (${index.columns.join(', ')})
        ${index.unique ? 'UNIQUE' : ''};
      `;
      await db.exec(createIndexSQL);
    }
  }
}

/**
 * Format default value for SQL
 */
function formatDefaultValue(value: unknown): string {
  if (value === null) return 'NULL';
  if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
  if (typeof value === 'number') return value.toString();
  if (typeof value === 'boolean') return value ? '1' : '0';
  throw new Error(`Unsupported default value type: ${typeof value}`);
}

// ============================================================================
// Database Health Checks
// ============================================================================

/**
 * Check database health
 */
export async function checkDatabaseHealth(): Promise<{
  isHealthy: boolean;
  tables: string[];
  error?: string;
}> {
  try {
    const { db } = await initDatabase();
    
    // Check if we can query the database
    const tables = await db.selectAll<{ name: string }>(`
      SELECT name FROM sqlite_master 
      WHERE type='table' AND name NOT LIKE 'sqlite_%'
    `);

    return {
      isHealthy: true,
      tables: tables.map(t => t.name)
    };
  } catch (error) {
    logger.error('[SQLite] Health check failed:', error);
    return {
      isHealthy: false,
      tables: [],
      error: error instanceof Error ? error.message : 'Unknown error'
    };
  }
}

/**
 * Verify database integrity
 */
export async function verifyDatabaseIntegrity(): Promise<{
  isIntegrityOk: boolean;
  errors: string[];
}> {
  const { db } = await initDatabase();
  const errors: string[] = [];

  try {
    // Run integrity check
    const result = await db.selectAll<{ integrity_check: string }>('PRAGMA integrity_check;');
    
    if (result[0]?.integrity_check !== 'ok') {
      errors.push('Database integrity check failed');
    }

    // Check foreign key constraints
    const fkResult = await db.selectAll<{ table: string; rowid: number; parent: string; fkid: number }>(`
      PRAGMA foreign_key_check;
    `);

    if (fkResult.length > 0) {
      errors.push('Foreign key constraint violations found');
    }

    return {
      isIntegrityOk: errors.length === 0,
      errors
    };
  } catch (error) {
    logger.error('[SQLite] Integrity check failed:', error);
    return {
      isIntegrityOk: false,
      errors: [error instanceof Error ? error.message : 'Unknown error']
    };
  }
}

// ============================================================================
// Database Backup and Recovery
// ============================================================================

/**
 * Create a database backup
 */
export async function createBackup(): Promise<Uint8Array> {
  const { db } = await initDatabase();
  
  try {
    // Export the database to a binary array
    return await db.export();
  } catch (error) {
    logger.error('[SQLite] Backup creation failed:', error);
    throw new Error('Failed to create database backup');
  }
}

/**
 * Restore database from backup
 */
export async function restoreFromBackup(backup: Uint8Array): Promise<void> {
  const { db } = await initDatabase();
  
  try {
    // Close current connection
    await closeDatabase();
    
    // Create new connection and import backup
    const sqlite3 = await import('@wa-sqlite/sql.js');
    const newDb = await sqlite3.open(backup);
    
    // Verify integrity
    const { isIntegrityOk, errors } = await verifyDatabaseIntegrity();
    if (!isIntegrityOk) {
      throw new Error(`Backup integrity check failed: ${errors.join(', ')}`);
    }
    
    // Replace current connection
    connection = {
      db: newDb,
      sqlite3,
      isOpen: true,
      lastUsed: Date.now()
    };
  } catch (error) {
    logger.error('[SQLite] Backup restoration failed:', error);
    throw new Error('Failed to restore database from backup');
  }
}