@jongodb/memory-server 0.1.1

package/dist/jest.js

@@ -0,0 +1,162 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { startJongodbMemoryServer, } from "./index.js";
+import { createJongodbEnvRuntime } from "./runtime.js";
+const DEFAULT_ENV_VAR_NAME = "MONGODB_URI";
+const DEFAULT_STATE_FILE = path.join(process.cwd(), ".jongodb", "jest-memory-server.json");
+const DEFAULT_STOP_TIMEOUT_MS = 5_000;
+export function registerJongodbForJest(hooks, options = {}) {
+    const runtime = createJongodbEnvRuntime(options);
+    hooks.beforeAll(async () => {
+        await runtime.setup();
+    });
+    hooks.afterAll(async () => {
+        await runtime.teardown();
+    });
+    return {
+        get uri() {
+            return runtime.uri;
+        },
+    };
+}
+export function createJestGlobalSetup(options = {}) {
+    return async () => {
+        const { envVarName, stateFile, runtimeOptions } = splitLifecycleOptions(options);
+        const server = await startJongodbMemoryServer(runtimeOptions);
+        process.env[envVarName] = server.uri;
+        await mkdir(path.dirname(stateFile), { recursive: true });
+        const state = {
+            uri: server.uri,
+            pid: server.pid,
+            envVarName,
+        };
+        await writeFile(stateFile, JSON.stringify(state, null, 2), "utf8");
+        server.detach();
+    };
+}
+export function createJestGlobalTeardown(options = {}) {
+    return async () => {
+        const { stateFile } = splitLifecycleOptions(options);
+        const state = await readJestGlobalState({ stateFile });
+        if (state === null) {
+            await rm(stateFile, { force: true });
+            return;
+        }
+        try {
+            await terminatePid(state.pid, options.killTimeoutMs ?? DEFAULT_STOP_TIMEOUT_MS);
+        }
+        finally {
+            await rm(stateFile, { force: true });
+        }
+    };
+}
+export async function readJestGlobalState(options = {}) {
+    const stateFile = normalizeStateFile(options.stateFile);
+    try {
+        const raw = await readFile(stateFile, "utf8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.uri !== "string" ||
+            typeof parsed.pid !== "number" ||
+            typeof parsed.envVarName !== "string") {
+            throw new Error("Jest global state file has invalid schema.");
+        }
+        return parsed;
+    }
+    catch (error) {
+        if (isMissingFileError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function readJestGlobalUri(options = {}) {
+    const state = await readJestGlobalState(options);
+    if (state === null) {
+        return null;
+    }
+    return state.uri;
+}
+function splitLifecycleOptions(options) {
+    const { envVarName, stateFile, killTimeoutMs: _killTimeoutMs, ...runtimeOptions } = options;
+    return {
+        envVarName: normalizeEnvVarName(envVarName),
+        stateFile: normalizeStateFile(stateFile),
+        runtimeOptions,
+    };
+}
+function normalizeEnvVarName(name) {
+    const normalized = name?.trim() || DEFAULT_ENV_VAR_NAME;
+    if (normalized.length === 0) {
+        throw new Error("envVarName must not be empty.");
+    }
+    return normalized;
+}
+function normalizeStateFile(stateFile) {
+    const normalized = stateFile?.trim() || DEFAULT_STATE_FILE;
+    if (normalized.length === 0) {
+        throw new Error("stateFile must not be empty.");
+    }
+    return normalized;
+}
+async function terminatePid(pid, timeoutMs) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        throw new Error(`Invalid PID in Jest global state: ${pid}`);
+    }
+    if (!isProcessRunning(pid)) {
+        return;
+    }
+    process.kill(pid, "SIGTERM");
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid)) {
+            return;
+        }
+        await sleep(50);
+    }
+    if (!isProcessRunning(pid)) {
+        return;
+    }
+    process.kill(pid, "SIGKILL");
+    await waitForProcessExit(pid, timeoutMs);
+    if (isProcessRunning(pid)) {
+        throw new Error(`Unable to stop detached Jest process pid=${pid} after SIGKILL.`);
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (isNoSuchProcessError(error)) {
+            return false;
+        }
+        throw error;
+    }
+}
+function isNoSuchProcessError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ESRCH");
+}
+function isMissingFileError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+async function waitForProcessExit(pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        if (!isProcessRunning(pid)) {
+            return;
+        }
+        await sleep(50);
+    }
+}

package/dist/nestjs.d.ts

@@ -0,0 +1,9 @@
+import { type JestHookOptions, type JestHookRegistrar, type RegisteredJongodbTestServer } from "./jest.js";
+export type NestJestHookRegistrar = JestHookRegistrar;
+export type NestJongodbOptions = JestHookOptions;
+export type RegisteredNestJongodbServer = RegisteredJongodbTestServer;
+/**
+ * Convenience wrapper for NestJS E2E tests that run on Jest.
+ */
+export declare function registerJongodbForNestJest(hooks: NestJestHookRegistrar, options?: NestJongodbOptions): RegisteredNestJongodbServer;
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/nestjs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nestjs.d.ts","sourceRoot":"","sources":["../src/nestjs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,2BAA2B,EAEjC,MAAM,WAAW,CAAC;AAEnB,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC;AACtD,MAAM,MAAM,kBAAkB,GAAG,eAAe,CAAC;AACjD,MAAM,MAAM,2BAA2B,GAAG,2BAA2B,CAAC;AAEtE;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,qBAAqB,EAC5B,OAAO,GAAE,kBAAuB,GAC/B,2BAA2B,CAE7B"}

package/dist/nestjs.js

@@ -0,0 +1,7 @@
+import { registerJongodbForJest, } from "./jest.js";
+/**
+ * Convenience wrapper for NestJS E2E tests that run on Jest.
+ */
+export function registerJongodbForNestJest(hooks, options = {}) {
+    return registerJongodbForJest(hooks, options);
+}

package/dist/runtime.d.ts

@@ -0,0 +1,13 @@
+import { type JongodbMemoryServerOptions } from "./index.js";
+export interface JongodbEnvRuntimeOptions extends JongodbMemoryServerOptions {
+    envVarName?: string;
+}
+export interface JongodbEnvRuntime {
+    readonly envVarName: string;
+    readonly running: boolean;
+    readonly uri: string;
+    setup(): Promise<string>;
+    teardown(): Promise<void>;
+}
+export declare function createJongodbEnvRuntime(options?: JongodbEnvRuntimeOptions): JongodbEnvRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,0BAA0B,EAEhC,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,wBAAyB,SAAQ,0BAA0B;IAC1E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACzB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED,wBAAgB,uBAAuB,CACrC,OAAO,GAAE,wBAA6B,GACrC,iBAAiB,CAkDnB"}

package/dist/runtime.js

@@ -0,0 +1,55 @@
+import { startJongodbMemoryServer, } from "./index.js";
+const DEFAULT_ENV_VAR_NAME = "MONGODB_URI";
+export function createJongodbEnvRuntime(options = {}) {
+    const envVarName = normalizeEnvVarName(options.envVarName);
+    const { envVarName: _envVarName, ...serverOptions } = options;
+    let runtimeServer = null;
+    let uri = null;
+    let previousEnvValue;
+    let hadPreviousEnv = false;
+    return {
+        envVarName,
+        get running() {
+            return runtimeServer !== null;
+        },
+        get uri() {
+            if (uri === null) {
+                throw new Error("Jongodb URI is not available before setup completes.");
+            }
+            return uri;
+        },
+        async setup() {
+            if (runtimeServer !== null && uri !== null) {
+                return uri;
+            }
+            hadPreviousEnv = Object.prototype.hasOwnProperty.call(process.env, envVarName);
+            previousEnvValue = process.env[envVarName];
+            runtimeServer = await startJongodbMemoryServer(serverOptions);
+            uri = runtimeServer.uri;
+            process.env[envVarName] = uri;
+            return uri;
+        },
+        async teardown() {
+            if (runtimeServer !== null) {
+                await runtimeServer.stop();
+                runtimeServer = null;
+            }
+            if (hadPreviousEnv) {
+                process.env[envVarName] = previousEnvValue;
+            }
+            else {
+                delete process.env[envVarName];
+            }
+            uri = null;
+            previousEnvValue = undefined;
+            hadPreviousEnv = false;
+        },
+    };
+}
+function normalizeEnvVarName(name) {
+    const normalized = name?.trim() || DEFAULT_ENV_VAR_NAME;
+    if (normalized.length === 0) {
+        throw new Error("envVarName must not be empty.");
+    }
+    return normalized;
+}

package/dist/vitest.d.ts

@@ -0,0 +1,13 @@
+import { type JongodbMemoryServerOptions } from "./index.js";
+export interface VitestHookRegistrar {
+    beforeAll(callback: () => unknown | Promise<unknown>): void;
+    afterAll(callback: () => unknown | Promise<unknown>): void;
+}
+export interface VitestHookOptions extends JongodbMemoryServerOptions {
+    envVarName?: string;
+}
+export interface RegisteredVitestJongodbServer {
+    readonly uri: string;
+}
+export declare function registerJongodbForVitest(hooks: VitestHookRegistrar, options?: VitestHookOptions): RegisteredVitestJongodbServer;
+//# sourceMappingURL=vitest.d.ts.map

package/dist/vitest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.d.ts","sourceRoot":"","sources":["../src/vitest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAG7D,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAC;CAC5D;AAED,MAAM,WAAW,iBAAkB,SAAQ,0BAA0B;IACnE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,mBAAmB,EAC1B,OAAO,GAAE,iBAAsB,GAC9B,6BAA6B,CAgB/B"}

package/dist/vitest.js

@@ -0,0 +1,15 @@
+import { createJongodbEnvRuntime } from "./runtime.js";
+export function registerJongodbForVitest(hooks, options = {}) {
+    const runtime = createJongodbEnvRuntime(options);
+    hooks.beforeAll(async () => {
+        await runtime.setup();
+    });
+    hooks.afterAll(async () => {
+        await runtime.teardown();
+    });
+    return {
+        get uri() {
+            return runtime.uri;
+        },
+    };
+}

package/package.json

@@ -0,0 +1,110 @@
+{
+  "name": "@jongodb/memory-server",
+  "version": "0.1.1",
+  "description": "Node.js test runtime adapter for jongodb standalone launcher (MongoDB-compatible integration tests).",
+  "keywords": [
+    "mongodb",
+    "mongodb-memory-server",
+    "jongodb",
+    "in-memory-mongodb",
+    "standalone-launcher",
+    "mongodb-test-runtime",
+    "integration-test",
+    "node-test",
+    "nestjs",
+    "express",
+    "fastify",
+    "mongoose",
+    "prisma",
+    "typeorm",
+    "jest",
+    "vitest",
+    "mocha",
+    "e2e"
+  ],
+  "license": "Apache-2.0",
+  "author": "jongodb contributors",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./jest": {
+      "types": "./dist/jest.d.ts",
+      "default": "./dist/jest.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    "./nestjs": {
+      "types": "./dist/nestjs.d.ts",
+      "default": "./dist/nestjs.js"
+    },
+    "./vitest": {
+      "types": "./dist/vitest.d.ts",
+      "default": "./dist/vitest.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "jest": [
+        "./dist/jest.d.ts"
+      ],
+      "runtime": [
+        "./dist/runtime.d.ts"
+      ],
+      "nestjs": [
+        "./dist/nestjs.d.ts"
+      ],
+      "vitest": [
+        "./dist/vitest.d.ts"
+      ]
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/midagedev/jongodb.git",
+    "directory": "packages/memory-server"
+  },
+  "bugs": {
+    "url": "https://github.com/midagedev/jongodb/issues"
+  },
+  "homepage": "https://github.com/midagedev/jongodb/tree/main/packages/memory-server#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "optionalDependencies": {
+    "@jongodb/memory-server-bin-darwin-arm64": "0.1.1",
+    "@jongodb/memory-server-bin-linux-x64-gnu": "0.1.1",
+    "@jongodb/memory-server-bin-win32-x64": "0.1.1"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "!dist/test",
+    "!dist/test/**"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "pretest": "npm run build",
+    "test": "node --test dist/test/*.test.js",
+    "prepack": "npm run clean && npm run build",
+    "release:check": "npm run build && npm run typecheck && npm run test && npm pack --dry-run"
+  },
+  "devDependencies": {
+    "@types/node": "^20.17.57",
+    "mongodb": "^6.21.0",
+    "typescript": "^5.9.2"
+  }
+}