postgres-memory-server 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,7 +1,8 @@
 // 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";
 
@@ -62,7 +63,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 {
     }
@@ -208,7 +210,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(
@@ -373,7 +375,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`;
@@ -385,9 +387,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 {
@@ -473,6 +527,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;
@@ -485,64 +563,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" });
@@ -574,6 +669,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(),
@@ -679,7 +782,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
@@ -718,7 +846,7 @@ import { spawn } from "child_process";
 import { createHash } from "crypto";
 import path3 from "path";
 import { tmpdir } from "os";
-import process2 from "process";
+import process3 from "process";
 import { fileURLToPath, pathToFileURL } from "url";
 var CHILD_OPTIONS_ENV_VAR = "POSTGRES_MEMORY_SERVER_CHILD_OPTIONS_B64";
 var CHILD_SETUP_TIMEOUT_MS = 12e4;
@@ -727,7 +855,7 @@ var POLL_INTERVAL_MS = 100;
 var DEFAULT_JEST_ENV_VAR_NAME = "DATABASE_URL";
 var DEFAULT_JEST_STATE_FILE = path3.join(
   tmpdir(),
-  `postgres-memory-server-jest-${createHash("sha256").update(process2.cwd()).digest("hex").slice(0, 12)}.json`
+  `postgres-memory-server-jest-${createHash("sha256").update(process3.cwd()).digest("hex").slice(0, 12)}.json`
 );
 function getChildScript(childModuleUrl) {
   return `
@@ -823,24 +951,24 @@ async function readStateFile(filePath) {
   }
 }
 function applyConnectionEnvironment(envVarName, payload) {
-  process2.env[envVarName] = payload.uri;
-  process2.env.POSTGRES_MEMORY_SERVER_URI = payload.uri;
-  process2.env.POSTGRES_MEMORY_SERVER_HOST = payload.host;
-  process2.env.POSTGRES_MEMORY_SERVER_PORT = String(payload.port);
-  process2.env.POSTGRES_MEMORY_SERVER_DATABASE = payload.database;
-  process2.env.POSTGRES_MEMORY_SERVER_USERNAME = payload.username;
-  process2.env.POSTGRES_MEMORY_SERVER_PASSWORD = payload.password;
-  process2.env.POSTGRES_MEMORY_SERVER_IMAGE = payload.image;
+  process3.env[envVarName] = payload.uri;
+  process3.env.POSTGRES_MEMORY_SERVER_URI = payload.uri;
+  process3.env.POSTGRES_MEMORY_SERVER_HOST = payload.host;
+  process3.env.POSTGRES_MEMORY_SERVER_PORT = String(payload.port);
+  process3.env.POSTGRES_MEMORY_SERVER_DATABASE = payload.database;
+  process3.env.POSTGRES_MEMORY_SERVER_USERNAME = payload.username;
+  process3.env.POSTGRES_MEMORY_SERVER_PASSWORD = payload.password;
+  process3.env.POSTGRES_MEMORY_SERVER_IMAGE = payload.image;
 }
 async function startChildProcess(options) {
   const childModuleUrl = await resolveChildModuleUrl();
   return new Promise((resolve, reject) => {
     const child = spawn(
-      process2.execPath,
+      process3.execPath,
       ["--input-type=module", "--eval", getChildScript(childModuleUrl)],
       {
         env: {
-          ...process2.env,
+          ...process3.env,
           [CHILD_OPTIONS_ENV_VAR]: Buffer.from(
             JSON.stringify(options),
             "utf8"
@@ -936,7 +1064,7 @@ async function resolveChildModuleUrl() {
 }
 async function stopChildProcess(pid) {
   try {
-    process2.kill(pid, "SIGTERM");
+    process3.kill(pid, "SIGTERM");
   } catch (error) {
     if (isMissingProcessError(error)) {
       return;
@@ -947,7 +1075,7 @@ async function stopChildProcess(pid) {
   while (Date.now() < deadline) {
     await sleep(POLL_INTERVAL_MS);
     try {
-      process2.kill(pid, 0);
+      process3.kill(pid, 0);
     } catch (error) {
       if (isMissingProcessError(error)) {
         return;