pgserve 0.1.5 → 1.0.2

package/src/router.js

@@ -1,19 +1,22 @@
 /**
- * Multi-Tenant Router (Performance Optimized)
+ * Multi-Tenant Router (TCP Proxy to Embedded PostgreSQL)
  *
- * Single TCP server that routes connections to different PGlite instances
- * based on database name from PostgreSQL connection string
+ * Single TCP server that routes connections to an embedded PostgreSQL instance.
+ * Extracts database name from PostgreSQL startup message, auto-creates database,
+ * then proxies the connection to real PostgreSQL.
  *
- * Performance Optimizations:
- * - Pino logger (5x faster than console.log)
- * - TCP socket optimizations (nodelay, keepalive)
- * - Minimal event emitter overhead
- * - Optimized connection tracking
+ * Features:
+ * - TRUE concurrent connections (native PostgreSQL)
+ * - Auto-provision databases on first connection
+ * - Zero configuration required
+ * - Memory mode (default) or persistent storage
  */
 
 import net from 'net';
-import { PGLiteSocketHandler } from '@electric-sql/pglite-socket';
-import { InstancePool } from './pool.js';
+import { PostgresManager } from './postgres.js';
+import { SyncManager } from './sync.js';
+import { RestoreManager } from './restore.js';
+import { Dashboard } from './dashboard.js';
 import { extractDatabaseNameFromSocket } from './protocol.js';
 import { EventEmitter } from 'events';
 import pino from 'pino';
@@ -24,13 +27,15 @@ import pino from 'pino';
 export class MultiTenantRouter extends EventEmitter {
   constructor(options = {}) {
     super();
-    this.port = options.port || 8432;
+    this.port = options.port || 5432;
     this.host = options.host || '127.0.0.1';
-    this.baseDir = options.baseDir || './data';
-    this.memoryMode = options.memoryMode || false;
-    this.maxInstances = options.maxInstances || 100;
+    this.baseDir = options.baseDir || null; // null = memory mode
+    this.memoryMode = !options.baseDir;
+    this.maxConnections = options.maxConnections || 1000;
     this.autoProvision = options.autoProvision !== false;
-    this.inspect = options.inspect || false;
+
+    // Internal PostgreSQL port (different from router port)
+    this.pgPort = options.pgPort || (this.port + 1000);
 
     // Pino logger (ultra-fast structured logging)
     const logLevel = options.logLevel || 'info';
@@ -42,13 +47,19 @@ export class MultiTenantRouter extends EventEmitter {
       } : undefined
     });
 
-    // Instance pool
-    this.pool = new InstancePool({
-      baseDir: this.baseDir,
-      memoryMode: this.memoryMode,
-      maxInstances: this.maxInstances,
-      autoProvision: this.autoProvision,
-      logger: this.logger.child({ component: 'pool' })
+    // Sync options (async replication to real PostgreSQL)
+    this.syncTo = options.syncTo || null;
+    this.syncDatabases = options.syncDatabases
+      ? options.syncDatabases.split(',').map(s => s.trim())
+      : [];
+    this.syncManager = null;
+
+    // PostgreSQL manager (with sync flag if needed)
+    this.pgManager = new PostgresManager({
+      dataDir: this.baseDir,
+      port: this.pgPort,
+      logger: this.logger.child({ component: 'postgres' }),
+      syncEnabled: !!this.syncTo  // Enable logical replication if sync is configured
     });
 
     // TCP server
@@ -56,21 +67,7 @@ export class MultiTenantRouter extends EventEmitter {
     this.connections = new Set();
 
     // Performance: Reduce event listener overhead
-    this.setMaxListeners(this.maxInstances + 10);
-
-    // Forward pool events (optimized logging)
-    this.pool.on('instance-created', (dbName) => {
-      this.logger.info({ dbName }, 'Database created');
-      this.emit('database-created', dbName);
-    });
-
-    this.pool.on('instance-locked', (dbName) => {
-      this.logger.debug({ dbName }, 'Database locked');
-    });
-
-    this.pool.on('instance-unlocked', (dbName) => {
-      this.logger.debug({ dbName }, 'Database unlocked');
-    });
+    this.setMaxListeners(this.maxConnections + 10);
   }
 
   /**
@@ -84,16 +81,6 @@ export class MultiTenantRouter extends EventEmitter {
     // Enable TCP keepalive (detect dead connections)
     socket.setKeepAlive(true, 60000); // 60s initial delay
 
-    // Increase socket buffer sizes for better throughput
-    // Note: These are hints to OS, actual values may differ
-    try {
-      socket.setRecvBufferSize && socket.setRecvBufferSize(128 * 1024); // 128KB
-      socket.setSendBufferSize && socket.setSendBufferSize(128 * 1024); // 128KB
-    } catch (err) {
-      // Ignore if not supported
-      this.logger.debug({ err }, 'Could not set socket buffer sizes');
-    }
-
     // Prevent socket timeout during long-running queries
     socket.setTimeout(0);
   }
@@ -102,19 +89,87 @@ export class MultiTenantRouter extends EventEmitter {
    * Start multi-tenant router
    */
   async start() {
-    return new Promise((resolve, reject) => {
-      // Create TCP server with optimizations
+    // Initialize dashboard for informative CLI output
+    const dashboard = new Dashboard();
+    dashboard.showHeader({
+      port: this.port,
+      host: this.host,
+      memoryMode: this.memoryMode,
+      syncTo: this.syncTo
+    });
+
+    // Start PostgreSQL first
+    dashboard.stage('PostgreSQL binaries resolved');
+    await this.pgManager.start();
+    dashboard.stage('PostgreSQL started');
+
+    // Automatic restore from external PostgreSQL (if sync configured)
+    // This runs BEFORE SyncManager to restore data before enabling outbound sync
+    if (this.syncTo) {
+      const restoreManager = new RestoreManager({
+        sourceUrl: this.syncTo,
+        patterns: this.syncDatabases,
+        targetPort: this.pgPort,
+        targetSocketPath: this.pgManager.getSocketPath(),
+        logger: this.logger.child({ component: 'restore' }),
+        onProgress: (metrics) => dashboard.updateRestore(metrics)
+      });
+
+      // Start restore progress display
+      dashboard.startRestore(restoreManager.totalDatabases || 1);
+
+      const restoreResult = await restoreManager.restore(this.pgManager);
+
+      if (restoreResult.success) {
+        dashboard.completeRestore(restoreResult.metrics);
+        this.logger.info({
+          databases: restoreResult.metrics.databasesRestored,
+          tables: restoreResult.metrics.tablesRestored,
+          rows: restoreResult.metrics.rowsRestored,
+          bytes: restoreResult.metrics.bytesTransferred,
+          durationMs: restoreResult.metrics.endTime - restoreResult.metrics.startTime
+        }, 'Restored from external PostgreSQL');
+      } else if (restoreResult.skipped) {
+        // No progress to complete - was skipped
+      } else {
+        dashboard.cleanup();
+        this.logger.warn({ error: restoreResult.error }, 'Restore failed (continuing without restored data)');
+      }
+    }
+
+    // Initialize SyncManager if configured (async replication)
+    if (this.syncTo) {
+      this.syncManager = new SyncManager({
+        targetUrl: this.syncTo,
+        databases: this.syncDatabases,
+        sourcePort: this.pgPort,
+        sourceSocketPath: this.pgManager.getSocketPath(),
+        logLevel: this.logger.level
+      });
+
+      // Wire SyncManager to PostgresManager for database creation hooks
+      this.pgManager.setSyncManager(this.syncManager);
+
+      // Initialize sync connections (non-blocking, runs in background)
+      this.syncManager.initialize(this.pgManager)
+        .then(() => {
+          dashboard.stage('Sync manager initialized');
+          this.logger.info('Sync manager initialized');
+        })
+        .catch(err => this.logger.warn({ err: err.message }, 'Sync manager initialization failed (non-fatal)'));
+    }
+
+    return new Promise((resolve, _reject) => {
+      // Create TCP server
       this.server = net.createServer({
-        // Performance: Allow half-open sockets (faster cleanup)
         allowHalfOpen: false,
-        // Performance: Pause on connect (manual resume after setup)
         pauseOnConnect: true
       }, async (socket) => {
         await this.handleConnection(socket);
       });
 
-      // Set max connections (system limit)
-      this.server.maxConnections = this.maxInstances * 2;
+      // Set max connections
+      this.server.maxConnections = this.maxConnections;
 
       // Error handling
       this.server.on('error', (error) => {
@@ -124,13 +179,20 @@ export class MultiTenantRouter extends EventEmitter {
 
       // Start listening
       this.server.listen(this.port, this.host, () => {
+        const socketPath = this.pgManager.getSocketPath();
+
+        dashboard.stage('TCP server listening');
+        dashboard.showReady({ port: this.port, host: this.host });
+
         this.logger.info({
           host: this.host,
           port: this.port,
+          pgPort: this.pgPort,
+          pgSocketPath: socketPath || '(TCP)',
           baseDir: this.memoryMode ? '(in-memory)' : this.baseDir,
           memoryMode: this.memoryMode,
           autoProvision: this.autoProvision,
-          maxInstances: this.maxInstances
+          maxConnections: this.maxConnections
         }, 'Multi-tenant router started');
 
         this.emit('listening');
@@ -140,91 +202,81 @@ export class MultiTenantRouter extends EventEmitter {
   }
 
   /**
-   * Handle incoming connection (Performance Optimized)
+   * Handle incoming connection (TCP Proxy)
+   * OPTIMIZED: Removed hot path logging for performance
    */
   async handleConnection(socket) {
-    const connId = `${socket.remoteAddress}:${socket.remotePort}`;
-    const startTime = Date.now();
-
-    // Optimize socket BEFORE any I/O
-    this.optimizeSocket(socket);
-
     // Track connection
     this.connections.add(socket);
 
-    // NOTE: Don't resume here - let readStartupMessage() resume after setting up listeners
-    // This prevents race condition where data arrives before listener is attached
+    // Optimize socket BEFORE any I/O
+    this.optimizeSocket(socket);
 
     let dbName = null;
-    let handler = null;
+    let pgSocket = null;
 
     try {
       // Extract database name from PostgreSQL handshake
-      this.logger.debug({ connId }, 'Reading startup message');
       const { dbName: extractedDbName, buffered } = await extractDatabaseNameFromSocket(socket);
       dbName = extractedDbName;
 
-      this.logger.info({ dbName, connId }, 'Connection request');
+      // Auto-provision database if needed
+      if (this.autoProvision) {
+        await this.pgManager.createDatabase(dbName);
+      }
 
-      // Get or create PGlite instance (with locking)
-      const instance = await this.pool.acquire(dbName, socket);
+      // Connect to real PostgreSQL (prefer Unix socket for speed)
+      const socketPath = this.pgManager.getSocketPath();
+      if (socketPath) {
+        // Unix socket connection (Linux/macOS) - ~30% faster than TCP
+        pgSocket = net.connect({ path: socketPath });
+      } else {
+        // TCP fallback (Windows)
+        pgSocket = net.connect({ host: '127.0.0.1', port: this.pgPort });
+      }
 
-      const routingTime = Date.now() - startTime;
-      this.logger.info({
-        dbName,
-        connId,
-        dataDir: instance.dataDir,
-        routingTimeMs: routingTime
-      }, 'Routed to database');
+      // Wait for PostgreSQL connection
+      await new Promise((resolve, reject) => {
+        pgSocket.once('connect', resolve);
+        pgSocket.once('error', reject);
+      });
 
-      // Push buffered data back to socket for handler to read
-      socket.unshift(buffered);
+      this.optimizeSocket(pgSocket);
 
-      // Create handler for this connection
-      handler = new PGLiteSocketHandler({
-        db: instance.db,
-        closeOnDetach: true,
-        inspect: this.inspect
-      });
+      // Send the buffered startup message to PostgreSQL
+      pgSocket.write(buffered);
 
-      // Attach socket to handler
-      await handler.attach(socket);
+      // Resume client socket (was paused on connect)
+      socket.resume();
 
-      this.logger.debug({ dbName, connId }, 'Socket attached');
+      // Bidirectional pipe (TRUE proxy)
+      socket.pipe(pgSocket);
+      pgSocket.pipe(socket);
 
-      // Handle socket close (cleanup)
+      // Handle cleanup - optimized: single handler, no logging in hot path
       const cleanup = () => {
-        this.logger.debug({ dbName, connId }, 'Connection closed');
-        if (handler) {
-          handler.detach();
-        }
         this.connections.delete(socket);
-        // Note: Don't call socket.removeAllListeners() here as it removes
-        // the pool's unlock handlers before they can fire, causing stuck locks
+        if (pgSocket && !pgSocket.destroyed) pgSocket.destroy();
+        if (socket && !socket.destroyed) socket.destroy();
       };
 
       socket.once('close', cleanup);
-      socket.once('error', (error) => {
-        this.logger.warn({ dbName, connId, err: error }, 'Socket error');
-        cleanup();
+      socket.once('error', cleanup);
+      pgSocket.once('close', () => {
+        if (socket && !socket.destroyed) socket.destroy();
       });
+      pgSocket.once('error', cleanup);
 
-      this.emit('connection', { dbName, socket, connId });
+      this.emit('connection', { dbName, socket });
     } catch (error) {
-      this.logger.error({ dbName, connId, err: error }, 'Connection error');
+      // Only log actual errors
+      this.logger.error({ dbName, err: error }, 'Connection error');
 
       // Cleanup
-      if (handler) {
-        try {
-          handler.detach();
-        } catch (detachErr) {
-          this.logger.debug({ err: detachErr }, 'Error detaching handler');
-        }
-      }
-
-      socket.destroy(); // Force close on error
+      if (pgSocket && !pgSocket.destroyed) pgSocket.destroy();
+      socket.destroy();
       this.connections.delete(socket);
-      this.emit('connection-error', { error, dbName, connId });
+      this.emit('connection-error', { error, dbName });
     }
   }
 
@@ -237,7 +289,7 @@ export class MultiTenantRouter extends EventEmitter {
     // Close all connections gracefully
     const activeConns = this.connections.size;
     for (const socket of this.connections) {
-      socket.end(); // Graceful close (vs destroy())
+      socket.end();
     }
     this.connections.clear();
 
@@ -248,12 +300,16 @@ export class MultiTenantRouter extends EventEmitter {
       });
     }
 
-    // Close all PGlite instances
-    await this.pool.closeAll();
+    // Stop SyncManager first (before PostgreSQL)
+    if (this.syncManager) {
+      await this.syncManager.stop();
+    }
+
+    // Stop PostgreSQL
+    await this.pgManager.stop();
 
     this.logger.info({
-      activeConnections: activeConns,
-      closedInstances: this.pool.instances.size
+      activeConnections: activeConns
     }, 'Router stopped');
 
     this.emit('stopped');
@@ -266,8 +322,9 @@ export class MultiTenantRouter extends EventEmitter {
     return {
       port: this.port,
       host: this.host,
+      pgPort: this.pgPort,
       activeConnections: this.connections.size,
-      pool: this.pool.getStats()
+      postgres: this.pgManager.getStats()
     };
   }
 
@@ -275,7 +332,7 @@ export class MultiTenantRouter extends EventEmitter {
    * List all databases
    */
   listDatabases() {
-    return this.pool.list();
+    return this.pgManager.getStats().databases;
   }
 }