queen-mq 0.2.0 → 0.2.11

package/src/cluster-server.js

@@ -1,242 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Queen Message Queue - Clustered Server
- * 
- * This module enables multi-core utilization using Node.js cluster module.
- * Each worker runs an independent instance of the Queen server, sharing the same port.
- * 
- * Benefits:
- * - 10x throughput improvement (utilizes all CPU cores)
- * - Automatic load balancing across workers
- * - Fault tolerance (automatic worker restart on crash)
- * - Zero-downtime deploys (rolling worker restarts)
- * 
- * Usage:
- *   node src/cluster-server.js
- *   
- * Environment Variables:
- *   QUEEN_WORKERS=N    - Number of workers (default: CPU count)
- *   WORKER_ID=name     - Base worker ID prefix (default: queen-worker)
- */
-
-import cluster from 'cluster';
-import os from 'os';
-import { log } from './utils/logger.js';
-
-// Configuration
-const numWorkers = parseInt(process.env.QUEEN_WORKERS) || os.cpus().length;
-const workerIdPrefix = process.env.WORKER_ID || 'queen-worker';
-
-if (cluster.isPrimary) {
-  console.log('');
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log('🚀 Queen Message Queue - Clustered Mode');
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log(`📊 System: ${os.cpus()[0].model}`);
-  console.log(`🔢 CPU Cores: ${os.cpus().length}`);
-  console.log(`👷 Starting Workers: ${numWorkers}`);
-  console.log(`🆔 Worker ID Prefix: ${workerIdPrefix}`);
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log('');
-
-  // Track worker statistics
-  const workerStats = {
-    startTime: Date.now(),
-    totalRestarts: 0,
-    workers: new Map()
-  };
-
-  // Graceful shutdown state (declared early for use in event handlers)
-  let isShuttingDown = false;
-  let forceExitTimeout = null;
-  let statusInterval = null;
-
-  // Fork workers
-  for (let i = 0; i < numWorkers; i++) {
-    forkWorker(i, workerStats);
-  }
-
-  // Handle worker exit
-  cluster.on('exit', (worker, code, signal) => {
-    const workerInfo = workerStats.workers.get(worker.id);
-    const workerId = workerInfo ? workerInfo.workerId : `worker-${worker.id}`;
-    const workerIndex = workerInfo ? workerInfo.index : 0;
-    
-    if (code !== 0 && !worker.exitedAfterDisconnect) {
-      // Unexpected crash
-      console.log('');
-      console.log(`⚠️  Worker ${workerId} (PID: ${worker.process.pid}) crashed!`);
-      console.log(`   Exit code: ${code}, Signal: ${signal}`);
-      console.log(`   Restarting worker...`);
-      
-      workerStats.totalRestarts++;
-      
-      // Remove from stats
-      workerStats.workers.delete(worker.id);
-      
-      // Restart with same index
-      setTimeout(() => {
-        forkWorker(workerIndex, workerStats);
-      }, 1000); // Wait 1 second before restart
-    } else {
-      // Graceful shutdown
-      console.log(`✅ Worker ${workerId} (PID: ${worker.process.pid}) exited gracefully`);
-      workerStats.workers.delete(worker.id);
-      
-      // Check if all workers have exited during shutdown
-      if (isShuttingDown && Object.keys(cluster.workers).length === 0) {
-        console.log('✅ All workers exited, shutting down master process');
-        clearInterval(statusInterval);
-        clearTimeout(forceExitTimeout);
-        process.exit(0);
-      }
-    }
-  });
-
-  // Handle worker online
-  cluster.on('online', (worker) => {
-    const workerInfo = workerStats.workers.get(worker.id);
-    if (workerInfo) {
-      // Update PID now that it's available
-      workerInfo.pid = worker.process.pid;
-      console.log(`✅ Worker ${workerInfo.workerId} (PID: ${worker.process.pid}) online and ready`);
-    } else {
-      console.log(`✅ Worker ${worker.id} (PID: ${worker.process.pid}) online`);
-    }
-  });
-
-  // Handle worker listening
-  cluster.on('listening', (worker, address) => {
-    const workerInfo = workerStats.workers.get(worker.id);
-    const workerId = workerInfo ? workerInfo.workerId : `worker-${worker.id}`;
-    console.log(`🎧 Worker ${workerId} listening on ${address.address}:${address.port}`);
-  });
-  
-  // Handle cluster errors
-  cluster.on('error', (error) => {
-    console.error('⚠️  Cluster error:', error.message);
-  });
-  
-  // Handle uncaught exceptions in master
-  process.on('uncaughtException', (error) => {
-    console.error('❌ Uncaught exception in master process:', error);
-    console.error(error.stack);
-    // Don't exit - try to keep the cluster running
-  });
-  
-  process.on('unhandledRejection', (reason, promise) => {
-    console.error('❌ Unhandled rejection in master process:', reason);
-    // Don't exit - try to keep the cluster running
-  });
-
-  // Graceful shutdown handling
-  const gracefulShutdown = (signal) => {
-    if (isShuttingDown) return;
-    isShuttingDown = true;
-    
-    console.log('');
-    console.log(`🛑 Received ${signal}, shutting down gracefully...`);
-    console.log(`📊 Total worker restarts during uptime: ${workerStats.totalRestarts}`);
-    console.log(`⏱️  Uptime: ${((Date.now() - workerStats.startTime) / 1000 / 60).toFixed(2)} minutes`);
-    
-    // Stop status reporting during shutdown
-    clearInterval(statusInterval);
-    
-    // Check if we already have no workers
-    if (Object.keys(cluster.workers).length === 0) {
-      console.log('✅ No active workers, exiting immediately');
-      process.exit(0);
-    }
-    
-    // Disconnect all workers
-    for (const id in cluster.workers) {
-      cluster.workers[id].disconnect();
-    }
-    
-    // Force exit if workers don't shut down in 10 seconds (reduced from 30)
-    forceExitTimeout = setTimeout(() => {
-      console.log('⚠️  Forcing shutdown after 10 second timeout');
-      console.log(`   Remaining workers: ${Object.keys(cluster.workers).length}`);
-      process.exit(0);
-    }, 10000);
-  };
-
-  process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
-  process.on('SIGINT', () => gracefulShutdown('SIGINT'));
-
-  // Status reporting every 60 seconds
-  statusInterval = setInterval(() => {
-    // Don't show status during shutdown
-    if (isShuttingDown) return;
-    
-    const aliveWorkers = Object.keys(cluster.workers).length;
-    const uptime = ((Date.now() - workerStats.startTime) / 1000 / 60).toFixed(2);
-    
-    console.log('');
-    console.log(`📊 Cluster Status (${new Date().toISOString()})`);
-    console.log(`   Active Workers: ${aliveWorkers}/${numWorkers}`);
-    console.log(`   Total Restarts: ${workerStats.totalRestarts}`);
-    console.log(`   Uptime: ${uptime} minutes`);
-  }, 60000);
-
-} else {
-  // Worker process - run the normal server
-  const workerId = process.env.WORKER_ID || `worker-${process.pid}`;
-  const workerIndex = process.env.WORKER_INDEX || '0';
-  
-  console.log(`👷 Worker ${workerId} (index: ${workerIndex}, PID: ${process.pid}) starting...`);
-  
-  try {
-    // Import and run the main server
-    await import('./server.js');
-    
-    // Worker-specific metrics could be added here
-    // e.g., track messages processed, errors, etc.
-  } catch (error) {
-    console.error(`❌ Worker ${workerId} failed to start:`, error.message);
-    console.error(error.stack);
-    process.exit(1);
-  }
-  
-  // Handle uncaught exceptions in worker
-  process.on('uncaughtException', (error) => {
-    console.error(`❌ Uncaught exception in worker ${workerId}:`, error);
-    process.exit(1);
-  });
-  
-  process.on('unhandledRejection', (reason, promise) => {
-    console.error(`❌ Unhandled rejection in worker ${workerId}:`, reason);
-    process.exit(1);
-  });
-}
-
-/**
- * Fork a new worker with proper environment setup
- */
-function forkWorker(index, stats) {
-  const workerId = `${workerIdPrefix}-${index}`;
-  
-  try {
-    const worker = cluster.fork({
-      WORKER_ID: workerId,
-      WORKER_INDEX: index.toString(),
-      // Each worker gets a unique ID for system events
-      SYSTEM_WORKER_ID: `${workerIdPrefix}-${index}-${Date.now()}`
-    });
-    
-    // Store worker info immediately (PID will be updated in 'online' event)
-    stats.workers.set(worker.id, {
-      workerId,
-      index,
-      startTime: Date.now(),
-      pid: null  // Will be set when worker comes online
-    });
-    
-    return worker;
-  } catch (error) {
-    console.error(`❌ Failed to fork worker ${workerId}:`, error.message);
-    return null;
-  }
-}
-

package/src/config.js

@@ -1,229 +0,0 @@
-/**
- * Centralized Configuration for Queen Message Queue System
- * 
- * All configuration values can be overridden using environment variables.
- * This file provides default values and documentation for all settings.
- */
-import os from 'os';
-
-// Server Configuration
-export const SERVER = {
-  PORT: parseInt(process.env.PORT) || 6632,
-  HOST: process.env.HOST || '0.0.0.0',
-  WORKER_ID: process.env.WORKER_ID || `worker-${os.hostname()}-${process.pid}`,
-  APPLICATION_NAME: process.env.APP_NAME || 'queen-mq'
-};
-
-// Database Configuration
-export const DATABASE = {
-  // Connection settings
-  USER: process.env.PG_USER || 'postgres',
-  HOST: process.env.PG_HOST || 'localhost',
-  DATABASE: process.env.PG_DB || 'postgres',
-  PASSWORD: process.env.PG_PASSWORD || 'postgres',
-  PORT: parseInt(process.env.PG_PORT) || 5432,
-  
-  // SSL configuration
-  USE_SSL: process.env.PG_USE_SSL === 'true',
-  SSL_REJECT_UNAUTHORIZED: process.env.PG_SSL_REJECT_UNAUTHORIZED !== 'false',
-  
-  // Pool configuration
-  POOL_SIZE: parseInt(process.env.DB_POOL_SIZE) || 150,
-  IDLE_TIMEOUT: parseInt(process.env.DB_IDLE_TIMEOUT) || 30000, // 30 seconds
-  CONNECTION_TIMEOUT: parseInt(process.env.DB_CONNECTION_TIMEOUT) || 2000, // 2 seconds
-  STATEMENT_TIMEOUT: parseInt(process.env.DB_STATEMENT_TIMEOUT) || 30000, // 30 seconds
-  QUERY_TIMEOUT: parseInt(process.env.DB_QUERY_TIMEOUT) || 30000, // 30 seconds
-  LOCK_TIMEOUT: parseInt(process.env.DB_LOCK_TIMEOUT) || 10000, // 10 seconds
-  
-  // Pool manager settings
-  MAX_RETRIES: parseInt(process.env.DB_MAX_RETRIES) || 3
-};
-
-// Queue Processing Configuration
-export const QUEUE = {
-  // Pop operation defaults
-  DEFAULT_TIMEOUT: parseInt(process.env.DEFAULT_TIMEOUT) || 30000, // 30 seconds
-  MAX_TIMEOUT: parseInt(process.env.MAX_TIMEOUT) || 60000, // 60 seconds
-  DEFAULT_BATCH_SIZE: parseInt(process.env.DEFAULT_BATCH_SIZE) || 1,
-  BATCH_INSERT_SIZE: parseInt(process.env.BATCH_INSERT_SIZE) || 1000,
-  
-  // Long polling
-  POLL_INTERVAL: parseInt(process.env.QUEUE_POLL_INTERVAL) || 100, // 100ms - initial poll interval
-  POLL_INTERVAL_FILTERED: parseInt(process.env.QUEUE_POLL_INTERVAL_FILTERED) || 50, // 50ms for better distribution across consumers
-  MAX_POLL_INTERVAL: parseInt(process.env.QUEUE_MAX_POLL_INTERVAL) || 2000, // 2000ms - max poll interval after backoff
-  BACKOFF_THRESHOLD: parseInt(process.env.QUEUE_BACKOFF_THRESHOLD) || 5, // Number of empty polls before backoff starts
-  BACKOFF_MULTIPLIER: parseFloat(process.env.QUEUE_BACKOFF_MULTIPLIER) || 2, // Exponential backoff multiplier
-  
-  // Partition selection for filtered pops (namespace/task)
-  MAX_PARTITION_CANDIDATES: parseInt(process.env.MAX_PARTITION_CANDIDATES) || 100, // Number of candidate partitions to fetch for lease acquisition
-  
-  // Queue defaults
-  DEFAULT_LEASE_TIME: parseInt(process.env.DEFAULT_LEASE_TIME) || 300, // 5 minutes
-  DEFAULT_RETRY_LIMIT: parseInt(process.env.DEFAULT_RETRY_LIMIT) || 3,
-  DEFAULT_RETRY_DELAY: parseInt(process.env.DEFAULT_RETRY_DELAY) || 1000, // 1 second
-  DEFAULT_MAX_SIZE: parseInt(process.env.DEFAULT_MAX_SIZE) || 10000,
-  DEFAULT_TTL: parseInt(process.env.DEFAULT_TTL) || 3600, // 1 hour
-  DEFAULT_PRIORITY: parseInt(process.env.DEFAULT_PRIORITY) || 0,
-  DEFAULT_DELAYED_PROCESSING: parseInt(process.env.DEFAULT_DELAYED_PROCESSING) || 0,
-  DEFAULT_WINDOW_BUFFER: parseInt(process.env.DEFAULT_WINDOW_BUFFER) || 0,
-  
-  // Dead Letter Queue
-  DEFAULT_DLQ_ENABLED: process.env.DEFAULT_DLQ_ENABLED === 'true' || false,
-  DEFAULT_DLQ_AFTER_MAX_RETRIES: process.env.DEFAULT_DLQ_AFTER_MAX_RETRIES === 'true' || false,
-  
-  // Retention defaults
-  DEFAULT_RETENTION_SECONDS: parseInt(process.env.DEFAULT_RETENTION_SECONDS) || 0,
-  DEFAULT_COMPLETED_RETENTION_SECONDS: parseInt(process.env.DEFAULT_COMPLETED_RETENTION_SECONDS) || 0,
-  DEFAULT_RETENTION_ENABLED: process.env.DEFAULT_RETENTION_ENABLED === 'true' || false,
-  
-  // Eviction
-  DEFAULT_MAX_WAIT_TIME_SECONDS: parseInt(process.env.DEFAULT_MAX_WAIT_TIME_SECONDS) || 0
-};
-
-// System Events Configuration
-export const SYSTEM_EVENTS = {
-  // Enable/disable system event propagation
-  ENABLED: process.env.QUEEN_SYSTEM_EVENTS_ENABLED === 'true' || false,
-  
-  // Batching window for event publishing (milliseconds)
-  BATCH_MS: parseInt(process.env.QUEEN_SYSTEM_EVENTS_BATCH_MS) || 10,
-  
-  // Timeout for startup synchronization (milliseconds)
-  SYNC_TIMEOUT: parseInt(process.env.QUEEN_SYSTEM_EVENTS_SYNC_TIMEOUT) || 30000
-};
-
-// Background Jobs Configuration
-export const JOBS = {
-  // Lease reclamation
-  LEASE_RECLAIM_INTERVAL: parseInt(process.env.LEASE_RECLAIM_INTERVAL) || 5000, // 5 seconds
-  
-  // Retention service
-  RETENTION_INTERVAL: parseInt(process.env.RETENTION_INTERVAL) || 300000, // 5 minutes
-  RETENTION_BATCH_SIZE: parseInt(process.env.RETENTION_BATCH_SIZE) || 1000,
-  PARTITION_CLEANUP_DAYS: parseInt(process.env.PARTITION_CLEANUP_DAYS) || 7,
-  
-  // Metrics retention (messages_consumed table)
-  METRICS_RETENTION_DAYS: parseInt(process.env.METRICS_RETENTION_DAYS) || 90, // Keep 90 days of metrics by default
-  
-  // Eviction service
-  EVICTION_INTERVAL: parseInt(process.env.EVICTION_INTERVAL) || 60000, // 1 minute
-  EVICTION_BATCH_SIZE: parseInt(process.env.EVICTION_BATCH_SIZE) || 1000,
-  
-  // WebSocket updates
-  QUEUE_DEPTH_UPDATE_INTERVAL: parseInt(process.env.QUEUE_DEPTH_UPDATE_INTERVAL) || 5000, // 5 seconds
-  SYSTEM_STATS_UPDATE_INTERVAL: parseInt(process.env.SYSTEM_STATS_UPDATE_INTERVAL) || 10000 // 10 seconds
-};
-
-// WebSocket Configuration
-export const WEBSOCKET = {
-  COMPRESSION: parseInt(process.env.WS_COMPRESSION) || 0,
-  MAX_PAYLOAD_LENGTH: parseInt(process.env.WS_MAX_PAYLOAD_LENGTH) || 16384, // 16KB
-  IDLE_TIMEOUT: parseInt(process.env.WS_IDLE_TIMEOUT) || 60, // 60 seconds
-  MAX_CONNECTIONS: parseInt(process.env.WS_MAX_CONNECTIONS) || 1000,
-  HEARTBEAT_INTERVAL: parseInt(process.env.WS_HEARTBEAT_INTERVAL) || 30000 // 30 seconds
-};
-
-// Encryption Configuration
-export const ENCRYPTION = {
-  KEY_ENV_VAR: 'QUEEN_ENCRYPTION_KEY',
-  ALGORITHM: 'aes-256-gcm',
-  KEY_LENGTH: 32, // bytes
-  IV_LENGTH: 16 // bytes
-};
-
-// Client SDK Configuration
-export const CLIENT = {
-  DEFAULT_BASE_URL: process.env.QUEEN_BASE_URL || 'http://localhost:6632',
-  DEFAULT_RETRY_ATTEMPTS: parseInt(process.env.CLIENT_RETRY_ATTEMPTS) || 3,
-  DEFAULT_RETRY_DELAY: parseInt(process.env.CLIENT_RETRY_DELAY) || 1000, // 1 second
-  DEFAULT_RETRY_BACKOFF: parseFloat(process.env.CLIENT_RETRY_BACKOFF) || 2,
-  CONNECTION_POOL_SIZE: parseInt(process.env.CLIENT_POOL_SIZE) || 10,
-  REQUEST_TIMEOUT: parseInt(process.env.CLIENT_REQUEST_TIMEOUT) || 30000 // 30 seconds
-};
-
-// API Configuration
-export const API = {
-  MAX_BODY_SIZE: parseInt(process.env.MAX_BODY_SIZE) || 100 * 1024 * 1024, // 100MB max body size
-  // Pagination
-  DEFAULT_LIMIT: parseInt(process.env.API_DEFAULT_LIMIT) || 100,
-  MAX_LIMIT: parseInt(process.env.API_MAX_LIMIT) || 1000,
-  DEFAULT_OFFSET: parseInt(process.env.API_DEFAULT_OFFSET) || 0,
-  
-  // CORS
-  CORS_MAX_AGE: parseInt(process.env.CORS_MAX_AGE) || 86400, // 24 hours
-  CORS_ALLOWED_ORIGINS: process.env.CORS_ALLOWED_ORIGINS || '*',
-  CORS_ALLOWED_METHODS: process.env.CORS_ALLOWED_METHODS || 'GET, POST, PUT, DELETE, OPTIONS',
-  CORS_ALLOWED_HEADERS: process.env.CORS_ALLOWED_HEADERS || 'Content-Type, Authorization'
-};
-
-// Analytics Configuration
-export const ANALYTICS = {
-  // Processing time calculations
-  RECENT_COMPLETION_HOURS: parseInt(process.env.ANALYTICS_RECENT_HOURS) || 24,
-  MIN_COMPLETED_FOR_STATS: parseInt(process.env.ANALYTICS_MIN_COMPLETED) || 5,
-  
-  // Time windows
-  RECENT_MESSAGE_WINDOW: parseInt(process.env.RECENT_MESSAGE_WINDOW) || 60, // 1 minute in seconds
-  RELATED_MESSAGE_WINDOW: parseInt(process.env.RELATED_MESSAGE_WINDOW) || 3600, // 1 hour in seconds
-  MAX_RELATED_MESSAGES: parseInt(process.env.MAX_RELATED_MESSAGES) || 10
-};
-
-// Performance Monitoring
-export const MONITORING = {
-  ENABLE_REQUEST_COUNTING: process.env.ENABLE_REQUEST_COUNTING !== 'false',
-  ENABLE_MESSAGE_COUNTING: process.env.ENABLE_MESSAGE_COUNTING !== 'false',
-  METRICS_ENDPOINT_ENABLED: process.env.METRICS_ENDPOINT_ENABLED !== 'false',
-  HEALTH_CHECK_ENABLED: process.env.HEALTH_CHECK_ENABLED !== 'false'
-};
-
-// Logging Configuration
-export const LOGGING = {
-  ENABLE_LOGGING: process.env.ENABLE_LOGGING !== 'false',
-  LOG_LEVEL: process.env.LOG_LEVEL || 'info',
-  LOG_FORMAT: process.env.LOG_FORMAT || 'json',
-  LOG_TIMESTAMP: process.env.LOG_TIMESTAMP !== 'false'
-};
-
-// HTTP Response Status Codes
-export const HTTP_STATUS = {
-  OK: 200,
-  CREATED: 201,
-  NO_CONTENT: 204,
-  BAD_REQUEST: 400,
-  NOT_FOUND: 404,
-  INTERNAL_SERVER_ERROR: 500,
-  SERVICE_UNAVAILABLE: 503
-};
-
-// Export a function to get the complete configuration
-export const getConfig = () => ({
-  server: SERVER,
-  database: DATABASE,
-  queue: QUEUE,
-  jobs: JOBS,
-  websocket: WEBSOCKET,
-  encryption: ENCRYPTION,
-  client: CLIENT,
-  api: API,
-  analytics: ANALYTICS,
-  monitoring: MONITORING,
-  logging: LOGGING,
-  httpStatus: HTTP_STATUS
-});
-
-// Export default configuration object
-export default {
-  SERVER,
-  DATABASE,
-  QUEUE,
-  SYSTEM_EVENTS,
-  JOBS,
-  WEBSOCKET,
-  ENCRYPTION,
-  CLIENT,
-  API,
-  ANALYTICS,
-  MONITORING,
-  LOGGING,
-  HTTP_STATUS
-};

package/src/database/connection.js

@@ -1,129 +0,0 @@
-import pg from 'pg';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import config from '../config.js';
-
-const { Pool } = pg;
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-/**
- * Create a PostgreSQL connection pool with proper configuration
- * This is the single source of truth for pool creation across the application
- */
-export const createPool = () => {
-  const poolConfig = {
-    user: config.DATABASE.USER,
-    host: config.DATABASE.HOST,
-    database: config.DATABASE.DATABASE,
-    password: config.DATABASE.PASSWORD,
-    port: config.DATABASE.PORT,
-    max: config.DATABASE.POOL_SIZE,
-    idleTimeoutMillis: config.DATABASE.IDLE_TIMEOUT,
-    connectionTimeoutMillis: config.DATABASE.CONNECTION_TIMEOUT,
-    // Note: statement_timeout and query_timeout cannot be set as startup parameters
-    // They should be set per-query or per-transaction using SET commands
-    application_name: config.SERVER.APPLICATION_NAME,
-    // PERFORMANCE NOTE: TCP_NODELAY for latency reduction
-    // The node-postgres driver enables TCP_NODELAY by default on sockets
-    // For server-side: Edit postgresql.conf and add: tcp_nodelay = on
-    // Reference: https://stackoverflow.com/questions/60634455/how-does-one-configure-tcp-nodelay-for-libpq-and-postgres-server
-    keepAlive: true,
-    keepAliveInitialDelayMillis: 10000
-  };
-
-  // Add SSL configuration if enabled
-  if (config.DATABASE.USE_SSL) {
-    poolConfig.ssl = {
-      rejectUnauthorized: config.DATABASE.SSL_REJECT_UNAUTHORIZED
-    };
-  }
-
-  return new Pool(poolConfig);
-};
-
-// Initialize database schema
-export const initDatabase = async (pool) => {
-  try {
-    // Check if the queen schema already exists
-    const schemaCheck = await pool.query(`
-      SELECT schema_name 
-      FROM information_schema.schemata 
-      WHERE schema_name = 'queen'
-    `);
-    
-    if (schemaCheck.rows.length > 0) {
-      console.log('Database schema already exists, skipping initialization');
-      return;
-    }
-    
-    // Schema doesn't exist, create it
-    const schemaPath = path.join(__dirname, 'schema-v2.sql');
-    const schema = fs.readFileSync(schemaPath, 'utf8');
-    
-    await pool.query(schema);
-    console.log('Database schema V2 initialized');
-  } catch (error) {
-    console.error('Failed to initialize database schema:', error);
-    throw error;
-  }
-};
-
-// Valid transaction isolation levels
-const VALID_ISOLATION_LEVELS = [
-  'READ COMMITTED',
-  'REPEATABLE READ', 
-  'SERIALIZABLE'
-];
-
-// Helper for transactions with retry logic
-export const withTransaction = async (pool, callback, isolationLevel = 'READ COMMITTED') => {
-  // Validate isolation level
-  if (isolationLevel && !VALID_ISOLATION_LEVELS.includes(isolationLevel)) {
-    throw new Error(`Invalid isolation level: ${isolationLevel}`);
-  }
-  
-  const maxAttempts = 3;
-  let attempt = 1;
-  
-  while (attempt <= maxAttempts) {
-    const client = await pool.connect();
-    try {
-      await client.query('BEGIN');
-      
-      if (isolationLevel) {
-        await client.query(`SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`);
-      }
-      
-      // Set timeouts to prevent long blocks
-      await client.query(`SET LOCAL statement_timeout = ${config.DATABASE.STATEMENT_TIMEOUT}`);
-      await client.query(`SET LOCAL lock_timeout = ${config.DATABASE.LOCK_TIMEOUT}`);
-      
-      const result = await callback(client);
-      await client.query('COMMIT');
-      return result;
-    } catch (error) {
-      await client.query('ROLLBACK');
-      
-      // Check for retriable errors:
-      // 40001: serialization_failure
-      // 40P01: deadlock_detected
-      // 55P03: lock_not_available (lock timeout)
-      // 25P02: in_failed_sql_transaction (transaction already aborted - retry whole transaction)
-      if ((error.code === '40001' || error.code === '40P01' || error.code === '55P03' || error.code === '25P02') && attempt < maxAttempts) {
-        // Exponential backoff: 100ms, 200ms, 400ms
-        const delay = Math.min(100 * Math.pow(2, attempt - 1), 1000);
-        await new Promise(resolve => setTimeout(resolve, delay));
-        attempt++;
-        console.log(`Transaction retry attempt ${attempt}/${maxAttempts} after ${error.code} (${error.message})`);
-        continue;
-      }
-      
-      throw error;
-    } finally {
-      client.release();
-    }
-  }
-  
-  throw new Error('Max transaction retry attempts exceeded');
-};