pgserve 2.1.3 → 2.2.0

package/tests/stress-test.js

@@ -1,439 +0,0 @@
-#!/usr/bin/env bun
-
-/**
- * pgserve Stress Test Suite
- *
- * Like PassMark but for PostgreSQL - progressive load testing with multiple scenarios.
- * Perfect for filming terminal under stress.
- *
- * Usage: bun tests/stress-test.js [port]
- */
-
-import pg from 'pg';
-const { Pool } = pg;
-
-const PORT = parseInt(process.argv[2]) || 8433;
-
-// ANSI colors
-const C = {
-  reset: '\x1b[0m',
-  bold: '\x1b[1m',
-  dim: '\x1b[2m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  cyan: '\x1b[36m',
-  red: '\x1b[31m',
-  magenta: '\x1b[35m',
-};
-
-const results = [];
-let globalPool = null;
-
-/**
- * Create a connection pool
- */
-function createPool(maxConnections) {
-  return new Pool({
-    host: '127.0.0.1',
-    port: PORT,
-    database: 'stresstest',
-    user: 'postgres',
-    password: 'postgres',
-    max: maxConnections,
-    idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 10000,
-  });
-}
-
-/**
- * Setup test tables
- */
-async function setup(pool) {
-  const client = await pool.connect();
-  try {
-    await client.query(`
-      DROP TABLE IF EXISTS stress_users CASCADE;
-      DROP TABLE IF EXISTS stress_orders CASCADE;
-      DROP TABLE IF EXISTS stress_logs CASCADE;
-
-      CREATE TABLE stress_users (
-        id SERIAL PRIMARY KEY,
-        name TEXT NOT NULL,
-        email TEXT,
-        created_at TIMESTAMP DEFAULT NOW()
-      );
-
-      CREATE TABLE stress_orders (
-        id SERIAL PRIMARY KEY,
-        user_id INTEGER,
-        amount DECIMAL(10,2),
-        status TEXT DEFAULT 'pending',
-        created_at TIMESTAMP DEFAULT NOW()
-      );
-
-      CREATE TABLE stress_logs (
-        id SERIAL PRIMARY KEY,
-        level TEXT,
-        message TEXT,
-        data JSONB,
-        created_at TIMESTAMP DEFAULT NOW()
-      );
-
-      CREATE INDEX idx_orders_user ON stress_orders(user_id);
-      CREATE INDEX idx_orders_status ON stress_orders(status);
-      CREATE INDEX idx_logs_level ON stress_logs(level);
-    `);
-  } finally {
-    client.release();
-  }
-}
-
-/**
- * Print banner
- */
-function banner() {
-  console.log(`
-${C.cyan}${C.bold}╔════════════════════════════════════════════════════════════════╗
-║                   pgserve STRESS TEST SUITE                    ║
-║                                                                ║
-║  Progressive load testing with multiple scenarios              ║
-╚════════════════════════════════════════════════════════════════╝${C.reset}
-
-${C.dim}Target: postgresql://127.0.0.1:${PORT}/stresstest${C.reset}
-`);
-}
-
-/**
- * Print section header
- */
-function section(name, description) {
-  console.log(`
-${C.yellow}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-${C.bold}${C.cyan}▶ ${name}${C.reset}
-${C.dim}${description}${C.reset}
-${C.yellow}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${C.reset}
-`);
-}
-
-/**
- * Progress bar
- */
-function progressBar(current, total, width = 30) {
-  const pct = Math.min(1, Math.max(0, current / total || 0));
-  // filled is clamped to [0, width], so (width - filled) is always non-negative
-  const filled = Math.max(0, Math.min(width, Math.round(pct * width)));
-  const empty = width - filled;
-  return `[${'█'.repeat(filled)}${'░'.repeat(empty)}] ${(pct * 100).toFixed(0)}%`;
-}
-
-/**
- * Run a test phase
- */
-async function runPhase(name, config) {
-  const { connections, duration, workload } = config;
-
-  const pool = createPool(connections);
-  const latencies = [];
-  let queries = 0;
-  let errors = 0;
-  let running = true;
-
-  const startTime = performance.now();
-
-  // Worker function
-  async function worker(id) {
-    while (running) {
-      const start = performance.now();
-      try {
-        await workload(pool, id);
-        latencies.push(performance.now() - start);
-        queries++;
-      } catch (err) {
-        // Only count errors while test is running (not pool shutdown errors)
-        if (running) {
-          errors++;
-        }
-      }
-    }
-  }
-
-  // Start workers
-  const workers = Array.from({ length: connections }, (_, i) => worker(i));
-
-  // Progress display
-  const progressInterval = setInterval(() => {
-    const elapsed = (performance.now() - startTime) / 1000;
-    const qps = queries / elapsed;
-    const progress = progressBar(elapsed, duration);
-    process.stdout.write(`\r  ${progress} | ${queries.toLocaleString()} queries | ${qps.toFixed(0)} QPS | ${errors} errors    `);
-  }, 200);
-
-  // Wait for duration
-  await new Promise(r => setTimeout(r, duration * 1000));
-  running = false;
-
-  // End pool immediately to unblock workers waiting for connections
-  // This is necessary because workers may be stuck in pool.connect() or pool.query()
-  await pool.end().catch(() => {});
-
-  // Wait for workers to finish (with timeout in case any are still stuck)
-  await Promise.race([
-    Promise.allSettled(workers),
-    new Promise(r => setTimeout(r, 2000)) // 2 second grace period
-  ]);
-  clearInterval(progressInterval);
-
-  const totalTime = (performance.now() - startTime) / 1000;
-
-  // Calculate stats
-  latencies.sort((a, b) => a - b);
-  const avg = latencies.length > 0 ? latencies.reduce((a, b) => a + b, 0) / latencies.length : 0;
-  const p50 = latencies[Math.floor(latencies.length * 0.5)] || 0;
-  const p95 = latencies[Math.floor(latencies.length * 0.95)] || 0;
-  const p99 = latencies[Math.floor(latencies.length * 0.99)] || 0;
-  const qps = queries / totalTime;
-
-  const result = {
-    name,
-    connections,
-    duration: totalTime,
-    queries,
-    errors,
-    qps,
-    latency: { avg, p50, p95, p99 }
-  };
-
-  results.push(result);
-
-  console.log(`\r  ${C.green}✓${C.reset} Complete: ${queries.toLocaleString()} queries in ${totalTime.toFixed(1)}s = ${C.bold}${qps.toFixed(0)} QPS${C.reset}    `);
-  console.log(`    ${C.dim}Latency: avg=${avg.toFixed(1)}ms p50=${p50.toFixed(1)}ms p95=${p95.toFixed(1)}ms p99=${p99.toFixed(1)}ms${C.reset}`);
-
-  return result;
-}
-
-// ============================================================================
-// WORKLOADS
-// ============================================================================
-
-const workloads = {
-  // Pure inserts
-  writeHeavy: async (pool, workerId) => {
-    await pool.query(
-      'INSERT INTO stress_logs (level, message, data) VALUES ($1, $2, $3)',
-      ['info', `Worker ${workerId} log entry`, JSON.stringify({ ts: Date.now(), worker: workerId })]
-    );
-  },
-
-  // Pure reads
-  readHeavy: async (pool) => {
-    await pool.query('SELECT * FROM stress_logs ORDER BY id DESC LIMIT 50');
-  },
-
-  // Mixed CRUD
-  mixed: async (pool, workerId) => {
-    const op = Math.random();
-    if (op < 0.3) {
-      // 30% writes
-      await pool.query(
-        'INSERT INTO stress_orders (user_id, amount, status) VALUES ($1, $2, $3)',
-        [Math.floor(Math.random() * 1000), Math.random() * 1000, 'pending']
-      );
-    } else if (op < 0.5) {
-      // 20% updates
-      await pool.query(
-        "UPDATE stress_orders SET status = $1 WHERE id = (SELECT id FROM stress_orders WHERE status = 'pending' LIMIT 1)",
-        ['completed']
-      );
-    } else {
-      // 50% reads
-      await pool.query('SELECT * FROM stress_orders WHERE status = $1 LIMIT 20', ['pending']);
-    }
-  },
-
-  // Complex queries with joins
-  complex: async (pool) => {
-    await pool.query(`
-      SELECT o.*, COUNT(*) OVER() as total
-      FROM stress_orders o
-      WHERE o.created_at > NOW() - INTERVAL '1 hour'
-      ORDER BY o.created_at DESC
-      LIMIT 10
-    `);
-  },
-
-  // Transaction heavy
-  transactions: async (pool) => {
-    const client = await pool.connect();
-    try {
-      await client.query('BEGIN');
-      await client.query(
-        'INSERT INTO stress_users (name, email) VALUES ($1, $2) RETURNING id',
-        [`User-${Date.now()}`, `user-${Date.now()}@test.com`]
-      );
-      await client.query(
-        'INSERT INTO stress_orders (user_id, amount) VALUES (currval(pg_get_serial_sequence(\'stress_users\', \'id\')), $1)',
-        [Math.random() * 500]
-      );
-      await client.query('COMMIT');
-    } catch (err) {
-      await client.query('ROLLBACK');
-      throw err;
-    } finally {
-      client.release();
-    }
-  },
-};
-
-// ============================================================================
-// MAIN TEST SUITE
-// ============================================================================
-
-async function runSuite() {
-  banner();
-
-  console.log(`${C.dim}Connecting and setting up test database...${C.reset}`);
-  globalPool = createPool(5);
-  await setup(globalPool);
-  console.log(`${C.green}✓${C.reset} Setup complete\n`);
-
-  // -------------------------------------------------------------------------
-  // TEST 1: Connection Ramp-Up
-  // -------------------------------------------------------------------------
-  section('TEST 1: Connection Ramp-Up', 'Gradually increasing concurrent connections');
-
-  for (const conns of [10, 50, 100, 250, 500]) {
-    console.log(`\n  ${C.cyan}→ ${conns} connections${C.reset}`);
-    await runPhase(`ramp-${conns}`, {
-      connections: conns,
-      duration: 10,
-      workload: workloads.mixed
-    });
-    await new Promise(r => setTimeout(r, 1000)); // Brief pause between phases
-  }
-
-  // -------------------------------------------------------------------------
-  // TEST 2: Write Stress
-  // -------------------------------------------------------------------------
-  section('TEST 2: Write Stress', 'Heavy INSERT workload - 200 connections, 15 seconds');
-
-  await runPhase('write-stress', {
-    connections: 200,
-    duration: 15,
-    workload: workloads.writeHeavy
-  });
-
-  // -------------------------------------------------------------------------
-  // TEST 3: Read Stress
-  // -------------------------------------------------------------------------
-  section('TEST 3: Read Stress', 'Heavy SELECT workload - 200 connections, 15 seconds');
-
-  await runPhase('read-stress', {
-    connections: 200,
-    duration: 15,
-    workload: workloads.readHeavy
-  });
-
-  // -------------------------------------------------------------------------
-  // TEST 4: Mixed Workload
-  // -------------------------------------------------------------------------
-  section('TEST 4: Mixed Workload', 'Real-world CRUD simulation - 300 connections, 20 seconds');
-
-  await runPhase('mixed-heavy', {
-    connections: 300,
-    duration: 20,
-    workload: workloads.mixed
-  });
-
-  // -------------------------------------------------------------------------
-  // TEST 5: Transaction Stress
-  // -------------------------------------------------------------------------
-  section('TEST 5: Transaction Stress', 'Multi-statement transactions - 150 connections, 15 seconds');
-
-  await runPhase('transactions', {
-    connections: 150,
-    duration: 15,
-    workload: workloads.transactions
-  });
-
-  // -------------------------------------------------------------------------
-  // TEST 6: Peak Load
-  // -------------------------------------------------------------------------
-  section('TEST 6: Peak Load', 'Maximum stress - 500 connections, 20 seconds');
-
-  await runPhase('peak-load', {
-    connections: 500,
-    duration: 20,
-    workload: workloads.mixed
-  });
-
-  // -------------------------------------------------------------------------
-  // TEST 7: Extreme Load
-  // -------------------------------------------------------------------------
-  section('TEST 7: Extreme Load', 'Near-limit stress - 750 connections, 15 seconds');
-
-  await runPhase('extreme-load', {
-    connections: 750,
-    duration: 15,
-    workload: workloads.mixed
-  });
-
-  // -------------------------------------------------------------------------
-  // FINAL REPORT
-  // -------------------------------------------------------------------------
-  await globalPool.end();
-
-  console.log(`
-${C.cyan}${C.bold}
-╔════════════════════════════════════════════════════════════════╗
-║                      FINAL RESULTS                             ║
-╚════════════════════════════════════════════════════════════════╝${C.reset}
-`);
-
-  // Summary table
-  console.log(`${C.bold}Test Name              Conn   Queries      QPS     Avg     P95     P99   Errors${C.reset}`);
-  console.log(`${'─'.repeat(85)}`);
-
-  let totalQueries = 0;
-  let totalErrors = 0;
-  let peakQps = 0;
-
-  for (const r of results) {
-    const name = r.name.padEnd(20);
-    const conn = String(r.connections).padStart(4);
-    const queries = r.queries.toLocaleString().padStart(10);
-    const qps = r.qps.toFixed(0).padStart(7);
-    const avg = r.latency.avg.toFixed(1).padStart(6) + 'ms';
-    const p95 = r.latency.p95.toFixed(1).padStart(6) + 'ms';
-    const p99 = r.latency.p99.toFixed(1).padStart(6) + 'ms';
-    const errors = String(r.errors).padStart(6);
-
-    const color = r.errors > 0 ? C.yellow : C.green;
-    console.log(`${color}${name} ${conn} ${queries} ${qps} ${avg} ${p95} ${p99} ${errors}${C.reset}`);
-
-    totalQueries += r.queries;
-    totalErrors += r.errors;
-    if (r.qps > peakQps) peakQps = r.qps;
-  }
-
-  console.log(`${'─'.repeat(85)}`);
-
-  // Score calculation (arbitrary but fun)
-  const score = Math.round((peakQps * 0.5) + (totalQueries / 1000) - (totalErrors * 10));
-
-  console.log(`
-${C.bold}Summary:${C.reset}
-  Total Queries:    ${totalQueries.toLocaleString()}
-  Total Errors:     ${totalErrors}
-  Peak QPS:         ${peakQps.toFixed(0)}
-
-${C.magenta}${C.bold}╔═══════════════════════════════════╗
-║  PGSERVE SCORE: ${String(score).padStart(6)}            ║
-╚═══════════════════════════════════╝${C.reset}
-`);
-}
-
-// Run
-runSuite().catch(err => {
-  console.error(`${C.red}Error:${C.reset}`, err);
-  process.exit(1);
-});

package/tests/sync-perf-test.js

@@ -1,150 +0,0 @@
-#!/usr/bin/env node
-/**
- * Sync Performance Impact Test
- *
- * Verifies that enabling sync has ZERO impact on hot path performance.
- * Runs identical workloads with and without sync, compares results.
- */
-
-import { startMultiTenantServer } from '../src/index.js';
-import pg from 'pg';
-
-const ITERATIONS = 1000;
-const WARMUP = 100;
-
-async function runWorkload(port, label) {
-  const client = new pg.Client({
-    host: 'localhost',
-    port,
-    database: 'perftest',
-    user: 'postgres',
-    password: 'postgres'
-  });
-
-  await client.connect();
-
-  // Create table
-  await client.query('CREATE TABLE IF NOT EXISTS bench (id SERIAL PRIMARY KEY, data TEXT)');
-  await client.query('TRUNCATE bench');
-
-  // Warmup
-  for (let i = 0; i < WARMUP; i++) {
-    await client.query('INSERT INTO bench (data) VALUES ($1)', [`warmup-${i}`]);
-  }
-  await client.query('TRUNCATE bench');
-
-  // Benchmark
-  const start = process.hrtime.bigint();
-
-  for (let i = 0; i < ITERATIONS; i++) {
-    await client.query('INSERT INTO bench (data) VALUES ($1)', [`row-${i}`]);
-  }
-
-  const insertEnd = process.hrtime.bigint();
-  const insertMs = Number(insertEnd - start) / 1_000_000;
-
-  // Read benchmark
-  const readStart = process.hrtime.bigint();
-  for (let i = 0; i < ITERATIONS; i++) {
-    await client.query('SELECT * FROM bench WHERE id = $1', [i % ITERATIONS + 1]);
-  }
-  const readEnd = process.hrtime.bigint();
-  const readMs = Number(readEnd - readStart) / 1_000_000;
-
-  await client.end();
-
-  return {
-    label,
-    inserts: {
-      total: insertMs,
-      perOp: insertMs / ITERATIONS,
-      opsPerSec: Math.round(ITERATIONS / (insertMs / 1000))
-    },
-    reads: {
-      total: readMs,
-      perOp: readMs / ITERATIONS,
-      opsPerSec: Math.round(ITERATIONS / (readMs / 1000))
-    }
-  };
-}
-
-async function main() {
-  console.log('='.repeat(60));
-  console.log('SYNC PERFORMANCE IMPACT TEST');
-  console.log('='.repeat(60));
-  console.log(`Iterations: ${ITERATIONS} | Warmup: ${WARMUP}`);
-  console.log();
-
-  // Test 1: Without sync
-  console.log('[1/2] Starting pgserve WITHOUT sync...');
-  const serverNoSync = await startMultiTenantServer({
-    port: 18001,
-    logLevel: 'error'
-  });
-
-  await new Promise(r => setTimeout(r, 2000)); // Wait for server
-  const resultNoSync = await runWorkload(18001, 'NO SYNC');
-  await serverNoSync.stop();
-
-  console.log('      Done.');
-  console.log();
-
-  // Test 2: With sync enabled (failing target - simulates sync overhead)
-  console.log('[2/2] Starting pgserve WITH sync (failing target)...');
-  const serverWithSync = await startMultiTenantServer({
-    port: 18002,
-    logLevel: 'error',
-    syncTo: 'postgresql://dummy:dummy@localhost:59999/fake', // Intentionally failing
-    syncDatabases: 'perftest'
-  });
-
-  await new Promise(r => setTimeout(r, 2000)); // Wait for server
-  const resultWithSync = await runWorkload(18002, 'WITH SYNC');
-  await serverWithSync.stop();
-
-  console.log('      Done.');
-  console.log();
-
-  // Results
-  console.log('='.repeat(60));
-  console.log('RESULTS');
-  console.log('='.repeat(60));
-  console.log();
-
-  console.log('INSERT PERFORMANCE:');
-  console.log(`  Without Sync: ${resultNoSync.inserts.opsPerSec.toLocaleString()} ops/sec (${resultNoSync.inserts.perOp.toFixed(2)} ms/op)`);
-  console.log(`  With Sync:    ${resultWithSync.inserts.opsPerSec.toLocaleString()} ops/sec (${resultWithSync.inserts.perOp.toFixed(2)} ms/op)`);
-
-  const insertDiff = ((resultWithSync.inserts.opsPerSec - resultNoSync.inserts.opsPerSec) / resultNoSync.inserts.opsPerSec * 100).toFixed(2);
-  console.log(`  Difference:   ${insertDiff > 0 ? '+' : ''}${insertDiff}%`);
-  console.log();
-
-  console.log('READ PERFORMANCE:');
-  console.log(`  Without Sync: ${resultNoSync.reads.opsPerSec.toLocaleString()} ops/sec (${resultNoSync.reads.perOp.toFixed(2)} ms/op)`);
-  console.log(`  With Sync:    ${resultWithSync.reads.opsPerSec.toLocaleString()} ops/sec (${resultWithSync.reads.perOp.toFixed(2)} ms/op)`);
-
-  const readDiff = ((resultWithSync.reads.opsPerSec - resultNoSync.reads.opsPerSec) / resultNoSync.reads.opsPerSec * 100).toFixed(2);
-  console.log(`  Difference:   ${readDiff > 0 ? '+' : ''}${readDiff}%`);
-  console.log();
-
-  // Verdict
-  console.log('='.repeat(60));
-  const threshold = 5; // 5% tolerance
-  const insertPass = Math.abs(parseFloat(insertDiff)) < threshold;
-  const readPass = Math.abs(parseFloat(readDiff)) < threshold;
-
-  if (insertPass && readPass) {
-    console.log('VERDICT: ✅ PASS - ZERO PERFORMANCE IMPACT');
-    console.log(`         (within ${threshold}% tolerance)`);
-  } else {
-    console.log('VERDICT: ❌ FAIL - PERFORMANCE REGRESSION DETECTED');
-  }
-  console.log('='.repeat(60));
-
-  process.exit(insertPass && readPass ? 0 : 1);
-}
-
-main().catch(e => {
-  console.error('Test failed:', e);
-  process.exit(1);
-});