pgserve 1.1.9 → 1.2.0

package/tests/multi-tenant.test.js

@@ -161,6 +161,170 @@ test('Multi-tenant router - multiple databases isolated', async () => {
   cleanup();
 });
 
+test('Router - pre-handshake buffer is bounded (issue #18 root cause #2)', async () => {
+  // Regression test for issue #18: without a bound on state.buffer, a
+  // client that sends garbage and never completes the PG startup would
+  // grow router memory unbounded (traced to the production 74 GiB VmSize).
+  // After fix, the router must close the connection once the buffer
+  // exceeds MAX_STARTUP_BUFFER_SIZE (1 MiB).
+  cleanup();
+
+  const router = await startMultiTenantServer({
+    port: 15546,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  const net = await import('net');
+  const sock = net.connect(15546, '127.0.0.1');
+  await new Promise((resolve) => sock.once('connect', resolve));
+
+  const garbage = Buffer.alloc(256 * 1024, 0x41); // 256 KiB of 'A'
+  let closed = false;
+  sock.on('close', () => { closed = true; });
+
+  // Send 5 × 256 KiB = 1.25 MiB, exceeding the 1 MiB cap.
+  for (let i = 0; i < 5 && !closed; i++) {
+    await new Promise((resolve) => sock.write(garbage, resolve));
+  }
+
+  // Wait up to 2s for the proxy to close the connection.
+  const deadline = Date.now() + 2000;
+  while (!closed && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 50));
+  }
+
+  expect(closed).toBe(true);
+  sock.destroy();
+
+  await router.stop();
+  cleanup();
+});
+
+test('Router - socket state has startupInProgress flag (issue #18 root cause #1)', async () => {
+  // White-box regression test for the reentrancy guard. Without
+  // state.startupInProgress, two data events arriving during the first
+  // processStartupMessage() await would launch concurrent async tasks
+  // that race to assign state.pgSocket, leaking the loser. This test
+  // verifies the flag is wired into the state object.
+  cleanup();
+
+  const router = await startMultiTenantServer({
+    port: 15547,
+    baseDir: testDataDir,
+    logLevel: 'warn',
+  });
+
+  const net = await import('net');
+  const sock = net.connect(15547, '127.0.0.1');
+  await new Promise((resolve) => sock.once('connect', resolve));
+
+  // Router tracks client sockets in this.connections; introspect to pull
+  // the state object and confirm the flag exists and defaults to false.
+  // On some platforms (macOS in particular) the client-side 'connect'
+  // event fires slightly before the server-side handleSocketOpen runs,
+  // so poll until the router has registered the connection rather than
+  // asserting synchronously.
+  const deadline = Date.now() + 2000;
+  while (router.connections.size === 0 && Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 20));
+  }
+  expect(router.connections.size).toBeGreaterThan(0);
+  const bunSocket = [...router.connections][0];
+  const state = router.socketState.get(bunSocket);
+  expect(state).toBeDefined();
+  expect(state.startupInProgress).toBe(false);
+
+  sock.destroy();
+  await router.stop();
+  cleanup();
+});
+
+test('PostgresManager - stop() nulls socketDir/databaseDir (issue #24)', async () => {
+  // Regression test for issue #24: router used to cache stale socketPath
+  // pointing to a directory that stop() had already rmSync'd. After fix,
+  // stop() nulls socketDir/databaseDir UNCONDITIONALLY so subsequent
+  // getSocketPath() returns null (forcing TCP fallback in the router).
+  cleanup();
+
+  const { PostgresManager } = await import('../src/postgres.js');
+  const { createLogger } = await import('../src/logger.js');
+  const pg = new PostgresManager({
+    port: 15543,
+    logger: createLogger({ level: 'warn' }),
+  });
+
+  await pg.start();
+  const socketPathBeforeStop = pg.getSocketPath();
+  expect(socketPathBeforeStop).not.toBeNull();
+  expect(fs.existsSync(pg.socketDir)).toBe(true);
+
+  await pg.stop();
+
+  // CORE ASSERTION: socketDir must be nulled after stop
+  expect(pg.socketDir).toBeNull();
+  expect(pg.getSocketPath()).toBeNull();
+  // databaseDir nulled only in memory mode (persistent mode keeps user-owned path)
+  expect(pg.databaseDir).toBeNull();
+  // And the dir on disk must actually be gone
+  // (socketPathBeforeStop points inside the deleted socketDir)
+  const staleSocketDir = path.dirname(socketPathBeforeStop);
+  expect(fs.existsSync(staleSocketDir)).toBe(false);
+});
+
+test('PostgresManager - start()+stop()+start() yields fresh socketDir (issue #24)', async () => {
+  // Regression test for issue #24: pgManager.start() called after stop()
+  // must produce a FRESH socketDir (different path). Without the fix, a
+  // re-entry guard was missing and socketDir could leak across restarts.
+  cleanup();
+
+  const { PostgresManager } = await import('../src/postgres.js');
+  const { createLogger } = await import('../src/logger.js');
+  const pg = new PostgresManager({
+    port: 15544,
+    logger: createLogger({ level: 'warn' }),
+  });
+
+  await pg.start();
+  const socketDir1 = pg.socketDir;
+  expect(socketDir1).not.toBeNull();
+
+  await pg.stop();
+  expect(pg.socketDir).toBeNull();
+
+  await pg.start();
+  const socketDir2 = pg.socketDir;
+  expect(socketDir2).not.toBeNull();
+  expect(socketDir2).not.toBe(socketDir1);
+  expect(fs.existsSync(socketDir2)).toBe(true);
+
+  await pg.stop();
+});
+
+test('PostgresManager - double start() is a no-op (issue #24 re-entry guard)', async () => {
+  // Without the guard, a second start() would overwrite socketDir/databaseDir
+  // and leak the previous tmp dir (the "1,457 stale sock dirs" symptom).
+  cleanup();
+
+  const { PostgresManager } = await import('../src/postgres.js');
+  const { createLogger } = await import('../src/logger.js');
+  const pg = new PostgresManager({
+    port: 15545,
+    logger: createLogger({ level: 'warn' }),
+  });
+
+  await pg.start();
+  const socketDir1 = pg.socketDir;
+
+  // Second start() should silently return the same instance without
+  // reassigning socketDir/databaseDir.
+  const result = await pg.start();
+  expect(result).toBe(pg);
+  expect(pg.socketDir).toBe(socketDir1);
+
+  await pg.stop();
+});
+
 test('Multi-tenant router - instance reuse', async () => {
   cleanup();
 

package/.github/release.yml

@@ -1,30 +0,0 @@
-# GitHub Release Notes Configuration
-# Automatically generates release notes from merged PRs
-# See: https://docs.github.com/en/repositories/releasing-projects-on-github/automatically-generated-release-notes
-
-changelog:
-  exclude:
-    labels:
-      - ignore-for-changelog
-      - internal
-      - bot
-    authors:
-      - github-actions[bot]
-  categories:
-    - title: "Features"
-      labels:
-        - feature
-        - enhancement
-    - title: "Bug Fixes"
-      labels:
-        - bug
-        - fix
-    - title: "Breaking Changes"
-      labels:
-        - breaking
-    - title: "Dependencies"
-      labels:
-        - dependencies
-    - title: "Other Changes"
-      labels:
-        - "*"

package/scripts/release.cjs

@@ -1,198 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Release Script for pgserve
- *
- * Usage:
- *   node scripts/release.cjs --action bump-rc|promote [--dry-run]
- *
- * Actions:
- *   bump-rc  - Bump RC version (1.0.8 -> 1.0.9-rc.1, or 1.0.9-rc.1 -> 1.0.9-rc.2)
- *   promote  - Promote RC to stable (1.0.9-rc.2 -> 1.0.9)
- *
- * Outputs (for GitHub Actions):
- *   version   - New version number
- *   tag       - Git tag (v1.0.9-rc.1)
- *   npm_tag   - npm dist-tag (next or latest)
- *   is_promote - true if this is a promotion (skip build)
- */
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-const ROOT = path.join(__dirname, '..');
-const PACKAGE_JSON = path.join(ROOT, 'package.json');
-
-// Parse arguments
-function parseArgs(args) {
-  const opts = {};
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    if (arg.startsWith('--')) {
-      const key = arg.replace(/^--/, '');
-      const nextArg = args[i + 1];
-      if (nextArg && !nextArg.startsWith('--')) {
-        opts[key] = nextArg;
-        i++;
-      } else {
-        opts[key] = true;
-      }
-    }
-  }
-  return opts;
-}
-
-const opts = parseArgs(process.argv.slice(2));
-const dryRun = opts['dry-run'] || false;
-
-function log(msg) {
-  console.log(`[release] ${msg}`);
-}
-
-function exec(cmd, options = {}) {
-  if (dryRun && !options.readOnly) {
-    log(`[dry-run] Would execute: ${cmd}`);
-    return '';
-  }
-  return execSync(cmd, { encoding: 'utf8', cwd: ROOT, ...options }).trim();
-}
-
-function getCurrentVersion() {
-  const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf8'));
-  return pkg.version;
-}
-
-function updateVersion(newVersion) {
-  const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf8'));
-  pkg.version = newVersion;
-  if (!dryRun) {
-    fs.writeFileSync(PACKAGE_JSON, JSON.stringify(pkg, null, 2) + '\n');
-  }
-  log(`Updated package.json version: ${newVersion}`);
-}
-
-function bumpRcVersion(currentVersion) {
-  // Check if already an RC: 1.0.9-rc.1 -> 1.0.9-rc.2
-  const rcMatch = currentVersion.match(/^(\d+\.\d+\.\d+)-rc\.(\d+)$/);
-  if (rcMatch) {
-    const [, base, rcNum] = rcMatch;
-    return `${base}-rc.${parseInt(rcNum) + 1}`;
-  }
-
-  // Not an RC, bump patch and start at rc.1: 1.0.8 -> 1.0.9-rc.1
-  const match = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)/);
-  if (!match) throw new Error(`Invalid version format: ${currentVersion}`);
-
-  const [, major, minor, patch] = match;
-  return `${major}.${minor}.${parseInt(patch) + 1}-rc.1`;
-}
-
-function promoteToStable(currentVersion) {
-  // If RC version: 1.0.9-rc.2 -> 1.0.9
-  const rcMatch = currentVersion.match(/^(\d+\.\d+\.\d+)-rc\.\d+$/);
-  if (rcMatch) {
-    return rcMatch[1];
-  }
-
-  // If already stable: 1.1.1 -> 1.1.2 (bump patch for new stable release)
-  const stableMatch = currentVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (stableMatch) {
-    const [, major, minor, patch] = stableMatch;
-    return `${major}.${minor}.${parseInt(patch) + 1}`;
-  }
-
-  throw new Error(`Invalid version format: ${currentVersion}`);
-}
-
-function createTag(version) {
-  const tag = `v${version}`;
-  const commitMsg = `chore: release ${tag}`;
-
-  if (dryRun) {
-    log(`[dry-run] Would commit: "${commitMsg}"`);
-    log(`[dry-run] Would create tag: ${tag}`);
-    return tag;
-  }
-
-  // Stage and commit
-  exec('git add package.json');
-  try {
-    exec(`git commit -m "${commitMsg}"`);
-  } catch (e) {
-    log('Nothing to commit (version already matches)');
-  }
-
-  // Create annotated tag
-  exec(`git tag -a ${tag} -m "Release ${tag}"`);
-  log(`Created tag: ${tag}`);
-
-  return tag;
-}
-
-function outputForGitHubActions(version, tag, isPromote) {
-  const output = process.env.GITHUB_OUTPUT;
-  if (output) {
-    const npmTag = version.includes('-rc.') ? 'next' : 'latest';
-    fs.appendFileSync(output, `version=${version}\n`);
-    fs.appendFileSync(output, `tag=${tag}\n`);
-    fs.appendFileSync(output, `npm_tag=${npmTag}\n`);
-    fs.appendFileSync(output, `is_promote=${isPromote}\n`);
-    log(`GitHub Actions outputs set: version=${version}, tag=${tag}, npm_tag=${npmTag}, is_promote=${isPromote}`);
-  }
-}
-
-async function main() {
-  const action = opts['action'];
-
-  if (!action) {
-    console.error('Usage: node scripts/release.cjs --action bump-rc|promote [--dry-run]');
-    console.error('');
-    console.error('Actions:');
-    console.error('  bump-rc  - Create new RC version');
-    console.error('  promote  - Promote current RC to stable');
-    process.exit(1);
-  }
-
-  const currentVersion = getCurrentVersion();
-  log(`Current version: ${currentVersion}`);
-
-  let newVersion;
-  let isPromote = false;
-
-  switch (action) {
-    case 'bump-rc':
-      newVersion = bumpRcVersion(currentVersion);
-      break;
-    case 'promote':
-      newVersion = promoteToStable(currentVersion);
-      isPromote = true;
-      break;
-    default:
-      console.error(`Unknown action: ${action}`);
-      console.error('Valid actions: bump-rc, promote');
-      process.exit(1);
-  }
-
-  log(`New version: ${newVersion}`);
-
-  // Update package.json
-  updateVersion(newVersion);
-
-  // Create git tag
-  const tag = createTag(newVersion);
-
-  // Output for GitHub Actions
-  // Note: Release notes are auto-generated by GitHub via .github/release.yml
-  outputForGitHubActions(newVersion, tag, isPromote);
-
-  log(`Release ${tag} prepared!`);
-  if (!dryRun) {
-    log('Push with: git push && git push --tags');
-  }
-}
-
-main().catch(e => {
-  console.error(`[release] Error: ${e.message}`);
-  process.exit(1);
-});