postgres-memory-server 0.2.0 → 0.2.1

package/dist/cli.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import process2 from "process";
+import process3 from "process";
 
 // src/PostgresMemoryServer.ts
-import { promises as fs2 } from "fs";
+import { promises as fs2, rmSync } from "fs";
 import os2 from "os";
 import path2 from "path";
+import process2 from "process";
 import EmbeddedPostgres from "embedded-postgres";
 import { Client } from "pg";
 
@@ -67,7 +68,8 @@ function getPgMajorVersion() {
       const content = readFileSync(candidate, "utf8");
       const pkg = JSON.parse(content);
       if (pkg.name === "embedded-postgres" && pkg.version) {
-        return pkg.version.split(".")[0];
+        const major = pkg.version.split(".")[0];
+        if (major) return major;
       }
     } catch {
     }
@@ -213,7 +215,7 @@ function buildDownloadUrl(version, pgMajorVersion, platform, arch) {
 }
 function getMacOSCodename() {
   const release = os.release();
-  const majorVersion = parseInt(release.split(".")[0], 10);
+  const majorVersion = parseInt(release.split(".")[0] ?? "0", 10);
   if (majorVersion >= 24) return "sequoia";
   if (majorVersion >= 23) return "sonoma";
   throw new Error(
@@ -378,7 +380,7 @@ async function installPgVectorExtension(nativeDir, pgMajorVersion) {
 function getHomebrewBottleTag(platform, arch) {
   if (platform === "darwin") {
     const release = os.release();
-    const major = parseInt(release.split(".")[0], 10);
+    const major = parseInt(release.split(".")[0] ?? "0", 10);
     const prefix = arch === "arm64" ? "arm64_" : "";
     if (major >= 25) return `${prefix}tahoe`;
     if (major >= 24) return `${prefix}sequoia`;
@@ -390,9 +392,61 @@ function getHomebrewBottleTag(platform, arch) {
   }
   throw new Error(`No Homebrew bottles available for ${platform}-${arch}`);
 }
+var ORPHAN_MIN_AGE_MS = 6e4;
+async function sweepOrphanedDataDirs(minAgeMs = ORPHAN_MIN_AGE_MS) {
+  const tmpDir = os.tmpdir();
+  let entries;
+  try {
+    entries = await fs.readdir(tmpDir);
+  } catch {
+    return;
+  }
+  const cutoff = Date.now() - minAgeMs;
+  await Promise.all(
+    entries.filter((name) => name.startsWith("postgres-memory-server-")).map(async (name) => {
+      const fullPath = path.join(tmpDir, name);
+      let stat;
+      try {
+        stat = await fs.stat(fullPath);
+        if (!stat.isDirectory()) return;
+      } catch {
+        return;
+      }
+      const pidFile = path.join(fullPath, "postmaster.pid");
+      let pid = null;
+      let pidFileExists = false;
+      try {
+        const content = await fs.readFile(pidFile, "utf8");
+        pidFileExists = true;
+        const firstLine = content.split("\n")[0]?.trim();
+        const parsed = firstLine ? parseInt(firstLine, 10) : NaN;
+        if (!Number.isNaN(parsed) && parsed > 0) {
+          pid = parsed;
+        }
+      } catch {
+      }
+      if (pid !== null) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch (err) {
+          const code = err.code;
+          if (code === "EPERM") {
+            return;
+          }
+        }
+      }
+      if (!pidFileExists && stat.mtimeMs > cutoff) {
+        return;
+      }
+      await fs.rm(fullPath, { recursive: true, force: true }).catch(() => {
+      });
+    })
+  );
+}
 function parseParadeDBVersion(version) {
   const match = version.match(/^(\d+\.\d+\.\d+)(?:-pg(\d+))?$/);
-  if (!match) {
+  if (!match || !match[1]) {
     return { extVersion: version };
   }
   return {
@@ -478,6 +532,30 @@ function quoteIdentifier(name) {
 }
 
 // src/PostgresMemoryServer.ts
+var liveInstances = /* @__PURE__ */ new Set();
+var exitHandlersRegistered = false;
+var orphanSweepDone = false;
+function registerExitHandlers() {
+  if (exitHandlersRegistered) return;
+  exitHandlersRegistered = true;
+  const cleanup = () => {
+    for (const instance of liveInstances) {
+      try {
+        instance._cleanupSync();
+      } catch {
+      }
+    }
+  };
+  process2.once("exit", cleanup);
+  const signalCleanup = (signal) => {
+    cleanup();
+    process2.removeListener(signal, signalCleanup);
+    process2.kill(process2.pid, signal);
+  };
+  process2.on("SIGINT", signalCleanup);
+  process2.on("SIGTERM", signalCleanup);
+  process2.on("SIGHUP", signalCleanup);
+}
 var PostgresMemoryServer = class _PostgresMemoryServer {
   constructor(pg, port, dataDir, options) {
     this.pg = pg;
@@ -490,64 +568,81 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
   snapshotSupported;
   hasSnapshot = false;
   static async create(options = {}) {
+    if (!orphanSweepDone) {
+      orphanSweepDone = true;
+      await sweepOrphanedDataDirs().catch(() => {
+      });
+    }
     const normalized = normalizeOptions(options);
     const port = await getFreePort();
     const dataDir = await fs2.mkdtemp(
       path2.join(os2.tmpdir(), "postgres-memory-server-")
     );
-    const postgresFlags = [];
-    if (normalized.preset === "paradedb") {
-      const nativeDir = getNativeDir();
-      const extVersion = resolveParadeDBVersion(normalized.version);
-      const pgMajor = DEFAULT_POSTGRES_VERSION;
-      try {
-        await installParadeDBExtension(nativeDir, extVersion, pgMajor);
-      } catch (error) {
-        throw new ExtensionInstallError(
-          "pg_search",
-          error instanceof Error ? error : new Error(String(error))
-        );
-      }
-      if (normalized.extensions.includes("vector")) {
+    let pg;
+    try {
+      const postgresFlags = [];
+      if (normalized.preset === "paradedb") {
+        const nativeDir = getNativeDir();
+        const extVersion = resolveParadeDBVersion(normalized.version);
+        const pgMajor = DEFAULT_POSTGRES_VERSION;
         try {
-          await installPgVectorExtension(nativeDir, pgMajor);
+          await installParadeDBExtension(nativeDir, extVersion, pgMajor);
         } catch (error) {
           throw new ExtensionInstallError(
-            "vector",
+            "pg_search",
             error instanceof Error ? error : new Error(String(error))
           );
         }
+        if (normalized.extensions.includes("vector")) {
+          try {
+            await installPgVectorExtension(nativeDir, pgMajor);
+          } catch (error) {
+            throw new ExtensionInstallError(
+              "vector",
+              error instanceof Error ? error : new Error(String(error))
+            );
+          }
+        }
+        if (normalized.extensions.includes("pg_search") || normalized.extensions.length === 0) {
+          postgresFlags.push("-c", "shared_preload_libraries=pg_search");
+        }
       }
-      if (normalized.extensions.includes("pg_search") || normalized.extensions.length === 0) {
-        postgresFlags.push(
-          "-c",
-          "shared_preload_libraries=pg_search"
-        );
+      pg = new EmbeddedPostgres({
+        databaseDir: dataDir,
+        port,
+        user: normalized.username,
+        password: normalized.password,
+        persistent: false,
+        postgresFlags,
+        onLog: () => {
+        },
+        onError: () => {
+        }
+      });
+      await pg.initialise();
+      await pg.start();
+      if (normalized.database !== "postgres") {
+        await pg.createDatabase(normalized.database);
       }
-    }
-    const pg = new EmbeddedPostgres({
-      databaseDir: dataDir,
-      port,
-      user: normalized.username,
-      password: normalized.password,
-      persistent: false,
-      postgresFlags,
-      onLog: () => {
-      },
-      onError: () => {
+      const server = new _PostgresMemoryServer(pg, port, dataDir, normalized);
+      liveInstances.add(server);
+      registerExitHandlers();
+      const initStatements = buildInitStatements(normalized);
+      if (initStatements.length > 0) {
+        await server.runSql(initStatements);
       }
-    });
-    await pg.initialise();
-    await pg.start();
-    if (normalized.database !== "postgres") {
-      await pg.createDatabase(normalized.database);
-    }
-    const server = new _PostgresMemoryServer(pg, port, dataDir, normalized);
-    const initStatements = buildInitStatements(normalized);
-    if (initStatements.length > 0) {
-      await server.runSql(initStatements);
+      return server;
+    } catch (error) {
+      if (pg) {
+        try {
+          await pg.stop();
+        } catch {
+        }
+      }
+      await fs2.rm(dataDir, { recursive: true, force: true }).catch(() => {
+      });
+      throw error;
     }
-    return server;
   }
   static createPostgres(options = {}) {
     return _PostgresMemoryServer.create({ ...options, preset: "postgres" });
@@ -579,6 +674,14 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
   getImage() {
     return this.options.image;
   }
+  /**
+   * Returns the absolute path to the temporary PostgreSQL data directory
+   * for this instance. Useful for debugging or backing up state. The
+   * directory is automatically removed by `stop()`.
+   */
+  getDataDir() {
+    return this.dataDir;
+  }
   getConnectionOptions() {
     return {
       host: this.getHost(),
@@ -684,7 +787,32 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
       return;
     }
     this.stopped = true;
-    await this.pg.stop();
+    liveInstances.delete(this);
+    try {
+      await this.pg.stop();
+    } catch {
+    }
+    await fs2.rm(this.dataDir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+  /**
+   * Synchronous cleanup for use in process exit handlers. Cannot await,
+   * so we just remove the data directory and let the OS reap the postgres
+   * child process. embedded-postgres registers its own exit hook to kill
+   * the process; this method is a backup for the data directory only.
+   *
+   * @internal
+   */
+  _cleanupSync() {
+    if (this.stopped) {
+      return;
+    }
+    this.stopped = true;
+    liveInstances.delete(this);
+    try {
+      rmSync(this.dataDir, { recursive: true, force: true });
+    } catch {
+    }
   }
   /**
    * Connect to the "postgres" system database for admin operations
@@ -719,7 +847,7 @@ var PostgresMemoryServer = class _PostgresMemoryServer {
 
 // src/cli.ts
 async function main() {
-  const { options, initFiles, json } = parseArgs(process2.argv.slice(2));
+  const { options, initFiles, json } = parseArgs(process3.argv.slice(2));
   const server = await PostgresMemoryServer.create(options);
   try {
     for (const file of initFiles) {
@@ -735,39 +863,39 @@ async function main() {
       image: server.getImage()
     };
     if (json) {
-      process2.stdout.write(`${JSON.stringify(payload, null, 2)}
+      process3.stdout.write(`${JSON.stringify(payload, null, 2)}
 `);
     } else {
-      process2.stdout.write(`POSTGRES_MEMORY_SERVER_URI=${payload.uri}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_URI=${payload.uri}
 `);
-      process2.stdout.write(`POSTGRES_MEMORY_SERVER_HOST=${payload.host}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_HOST=${payload.host}
 `);
-      process2.stdout.write(`POSTGRES_MEMORY_SERVER_PORT=${payload.port}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_PORT=${payload.port}
 `);
-      process2.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_DATABASE=${payload.database}
 `
       );
-      process2.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_USERNAME=${payload.username}
 `
       );
-      process2.stdout.write(
+      process3.stdout.write(
         `POSTGRES_MEMORY_SERVER_PASSWORD=${payload.password}
 `
       );
-      process2.stdout.write(`POSTGRES_MEMORY_SERVER_IMAGE=${payload.image}
+      process3.stdout.write(`POSTGRES_MEMORY_SERVER_IMAGE=${payload.image}
 `);
-      process2.stdout.write("\nPress Ctrl+C to stop the server.\n");
+      process3.stdout.write("\nPress Ctrl+C to stop the server.\n");
     }
     const stop = async () => {
       await server.stop();
-      process2.exit(0);
+      process3.exit(0);
     };
-    process2.on("SIGINT", () => {
+    process3.on("SIGINT", () => {
       void stop();
     });
-    process2.on("SIGTERM", () => {
+    process3.on("SIGTERM", () => {
       void stop();
     });
     await new Promise(() => {
@@ -829,7 +957,7 @@ function parseArgs(argv) {
       }
       case "--help": {
         printHelp();
-        process2.exit(0);
+        process3.exit(0);
       }
       default: {
         throw new Error(`Unknown argument: ${arg}`);
@@ -849,36 +977,36 @@ function readValue(argv, index, flag) {
   return value;
 }
 function printHelp() {
-  process2.stdout.write(`postgres-memory-server
+  process3.stdout.write(`postgres-memory-server
 
 `);
-  process2.stdout.write(`Options:
+  process3.stdout.write(`Options:
 `);
-  process2.stdout.write(`  --preset postgres|paradedb
+  process3.stdout.write(`  --preset postgres|paradedb
 `);
-  process2.stdout.write(`  --version <tag>
+  process3.stdout.write(`  --version <tag>
 `);
-  process2.stdout.write(`  --image <image>         (deprecated, ignored)
+  process3.stdout.write(`  --image <image>         (deprecated, ignored)
 `);
-  process2.stdout.write(`  --database <name>
+  process3.stdout.write(`  --database <name>
 `);
-  process2.stdout.write(`  --username <name>
+  process3.stdout.write(`  --username <name>
 `);
-  process2.stdout.write(`  --password <password>
+  process3.stdout.write(`  --password <password>
 `);
-  process2.stdout.write(`  --extension <name>      repeatable
+  process3.stdout.write(`  --extension <name>      repeatable
 `);
-  process2.stdout.write(`  --init-file <path>      repeatable
+  process3.stdout.write(`  --init-file <path>      repeatable
 `);
-  process2.stdout.write(`  --json
+  process3.stdout.write(`  --json
 `);
-  process2.stdout.write(`  --help
+  process3.stdout.write(`  --help
 `);
 }
 void main().catch((error) => {
   const message = error instanceof Error ? error.stack ?? error.message : String(error);
-  process2.stderr.write(`${message}
+  process3.stderr.write(`${message}
 `);
-  process2.exit(1);
+  process3.exit(1);
 });
 //# sourceMappingURL=cli.js.map