@jongodb/memory-server 0.1.1

package/dist/index.js

@@ -0,0 +1,539 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { delimiter, dirname, resolve } from "node:path";
+import { createInterface } from "node:readline";
+const require = createRequire(import.meta.url);
+const READY_PREFIX = "JONGODB_URI=";
+const FAILURE_PREFIX = "JONGODB_START_FAILURE=";
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_DATABASE = "test";
+const DEFAULT_STARTUP_TIMEOUT_MS = 15_000;
+const DEFAULT_STOP_TIMEOUT_MS = 5_000;
+const DEFAULT_LAUNCHER_CLASS = "org.jongodb.server.TcpMongoServerLauncher";
+const MAX_LOG_LINES = 50;
+const BUNDLED_BINARY_PACKAGE_PREFIX = "@jongodb/memory-server-bin";
+export async function startJongodbMemoryServer(options = {}) {
+    const startupTimeoutMs = normalizeTimeout(options.startupTimeoutMs, DEFAULT_STARTUP_TIMEOUT_MS, "startupTimeoutMs");
+    const stopTimeoutMs = normalizeTimeout(options.stopTimeoutMs, DEFAULT_STOP_TIMEOUT_MS, "stopTimeoutMs");
+    const host = normalizeHost(options.host);
+    const port = normalizePort(options.port);
+    const databaseName = normalizeDatabaseName(options.databaseName);
+    const logLevel = options.logLevel ?? "silent";
+    const launchConfigs = resolveLaunchConfigs(options, {
+        host,
+        port,
+        databaseName,
+    });
+    const launchErrors = [];
+    for (let index = 0; index < launchConfigs.length; index += 1) {
+        const launchConfig = launchConfigs[index];
+        try {
+            return await startWithLaunchConfig(launchConfig, {
+                startupTimeoutMs,
+                stopTimeoutMs,
+                logLevel,
+                env: options.env,
+            });
+        }
+        catch (error) {
+            const normalized = wrapError(error);
+            launchErrors.push(`[${launchConfig.mode}:${launchConfig.source}] ${normalized.message}`);
+        }
+    }
+    throw new Error([
+        "Failed to start jongodb with available launch configurations.",
+        ...launchErrors,
+    ].join(" "));
+}
+async function startWithLaunchConfig(launchConfig, context) {
+    const child = spawn(launchConfig.command, launchConfig.args, {
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        env: {
+            ...process.env,
+            ...context.env,
+        },
+    });
+    const stdoutLines = [];
+    const stderrLines = [];
+    let exitResult = null;
+    let stopped = false;
+    child.on("exit", (code, signal) => {
+        exitResult = { code, signal };
+    });
+    const stdoutReader = createInterface({ input: child.stdout });
+    const stderrReader = createInterface({ input: child.stderr });
+    const startupResult = await waitForStartup({
+        child,
+        stdoutReader,
+        stderrReader,
+        stdoutLines,
+        stderrLines,
+        startupTimeoutMs: context.startupTimeoutMs,
+        logLevel: context.logLevel,
+        launchDescription: `${launchConfig.mode}:${launchConfig.source}`,
+    }).catch(async (error) => {
+        await forceStopIfAlive(child, context.stopTimeoutMs);
+        throw wrapError(error);
+    });
+    const stop = async () => {
+        if (stopped) {
+            return;
+        }
+        stopped = true;
+        stdoutReader.close();
+        stderrReader.close();
+        if (exitResult !== null || child.exitCode !== null) {
+            return;
+        }
+        const terminated = child.kill("SIGTERM");
+        if (!terminated) {
+            if (exitResult !== null || child.exitCode !== null) {
+                return;
+            }
+            throw new Error("Failed to stop jongodb server process: unable to send SIGTERM.");
+        }
+        const gracefulExit = await waitForExit(child, context.stopTimeoutMs);
+        if (gracefulExit !== null) {
+            return;
+        }
+        const killed = child.kill("SIGKILL");
+        if (!killed) {
+            throw new Error("Failed to stop jongodb server process: SIGTERM timeout and SIGKILL failed.");
+        }
+        const forcedExit = await waitForExit(child, context.stopTimeoutMs);
+        if (forcedExit === null) {
+            throw new Error("Failed to stop jongodb server process: process did not exit after SIGKILL.");
+        }
+    };
+    if (child.pid === undefined) {
+        throw new Error("Jongodb process started without a PID.");
+    }
+    const detach = () => {
+        stdoutReader.close();
+        stderrReader.close();
+        child.stdout.destroy();
+        child.stderr.destroy();
+        child.unref();
+    };
+    return {
+        uri: startupResult.uri,
+        pid: child.pid,
+        detach,
+        stop,
+    };
+}
+function resolveLaunchConfigs(options, context) {
+    const mode = options.launchMode ?? "auto";
+    if (mode !== "auto" && mode !== "binary" && mode !== "java") {
+        throw new Error(`launchMode must be one of: auto, binary, java (got: ${mode}).`);
+    }
+    const binary = resolveBinaryCandidate(options.binaryPath);
+    const java = resolveJavaCandidate(options);
+    if (mode === "binary") {
+        if (binary === null) {
+            throw new Error([
+                "Binary launch mode requested but no binary was found.",
+                "Provide options.binaryPath or JONGODB_BINARY_PATH.",
+                bundledBinaryHint(),
+            ].join(" "));
+        }
+        return [toBinaryLaunchConfig(binary.path, binary.source, context)];
+    }
+    if (mode === "java") {
+        if (java === null) {
+            throw new Error([
+                "Java launch mode requested but Java classpath is not configured.",
+                "Pass options.classpath or set JONGODB_CLASSPATH.",
+                "Example (repo-local): ./.tooling/gradle-8.10.2/bin/gradle -q printLauncherClasspath",
+            ].join(" "));
+        }
+        return [toJavaLaunchConfig(java, context)];
+    }
+    if (binary !== null && java !== null) {
+        return [
+            toBinaryLaunchConfig(binary.path, binary.source, context),
+            toJavaLaunchConfig(java, context),
+        ];
+    }
+    if (binary !== null) {
+        return [toBinaryLaunchConfig(binary.path, binary.source, context)];
+    }
+    if (java !== null) {
+        return [toJavaLaunchConfig(java, context)];
+    }
+    throw new Error([
+        "No launcher runtime configured.",
+        "Provide one of:",
+        "1) options.binaryPath or JONGODB_BINARY_PATH",
+        "2) options.classpath or JONGODB_CLASSPATH",
+        bundledBinaryHint(),
+    ].join(" "));
+}
+function toBinaryLaunchConfig(binaryPath, source, context) {
+    return {
+        mode: "binary",
+        command: binaryPath,
+        args: [
+            `--host=${context.host}`,
+            `--port=${context.port}`,
+            `--database=${context.databaseName}`,
+        ],
+        source,
+    };
+}
+function toJavaLaunchConfig(java, context) {
+    return {
+        mode: "java",
+        command: java.javaPath,
+        args: [
+            "-cp",
+            java.classpath,
+            java.launcherClass,
+            `--host=${context.host}`,
+            `--port=${context.port}`,
+            `--database=${context.databaseName}`,
+        ],
+        source: java.source,
+    };
+}
+function resolveBinaryCandidate(explicitBinaryPath) {
+    const fromOption = normalizeBinaryPath(explicitBinaryPath, "options.binaryPath");
+    if (fromOption !== null) {
+        return { path: fromOption, source: "options.binaryPath" };
+    }
+    const fromEnv = normalizeBinaryPath(process.env.JONGODB_BINARY_PATH, "JONGODB_BINARY_PATH");
+    if (fromEnv !== null) {
+        return { path: fromEnv, source: "JONGODB_BINARY_PATH" };
+    }
+    const fromBundled = resolveBundledBinaryPath();
+    if (fromBundled !== null) {
+        return fromBundled;
+    }
+    return null;
+}
+function normalizeBinaryPath(value, fieldName) {
+    if (value === undefined) {
+        return null;
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        throw new Error(`${fieldName} must not be empty when provided.`);
+    }
+    return normalized;
+}
+function resolveBundledBinaryPath() {
+    const candidates = bundledBinaryPackageCandidates();
+    for (const packageName of candidates) {
+        const pathFromPackage = resolveBinaryPathFromPackage(packageName);
+        if (pathFromPackage !== null) {
+            return {
+                path: pathFromPackage,
+                source: `bundled-package:${packageName}`,
+            };
+        }
+    }
+    return null;
+}
+function bundledBinaryPackageCandidates() {
+    const platform = process.platform;
+    const arch = process.arch;
+    if (platform === "darwin") {
+        return [`${BUNDLED_BINARY_PACKAGE_PREFIX}-darwin-${arch}`];
+    }
+    if (platform === "win32") {
+        return [`${BUNDLED_BINARY_PACKAGE_PREFIX}-win32-${arch}`];
+    }
+    if (platform === "linux") {
+        const libcVariant = detectLinuxLibcVariant();
+        return [
+            `${BUNDLED_BINARY_PACKAGE_PREFIX}-linux-${arch}-${libcVariant}`,
+            `${BUNDLED_BINARY_PACKAGE_PREFIX}-linux-${arch}`,
+        ];
+    }
+    return [];
+}
+function detectLinuxLibcVariant() {
+    const report = process.report?.getReport?.();
+    const glibcVersionRuntime = report?.header?.glibcVersionRuntime;
+    if (typeof glibcVersionRuntime === "string" && glibcVersionRuntime.length > 0) {
+        return "gnu";
+    }
+    return "musl";
+}
+function resolveBinaryPathFromPackage(packageName) {
+    try {
+        const packageJsonPath = require.resolve(`${packageName}/package.json`);
+        const packageDir = dirname(packageJsonPath);
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        const binaryRelativePath = readJongodbBinaryPath(packageJson) ??
+            readBinEntryPath(packageJson.bin);
+        if (binaryRelativePath === null) {
+            return null;
+        }
+        return resolve(packageDir, binaryRelativePath);
+    }
+    catch {
+        return null;
+    }
+}
+function readJongodbBinaryPath(packageJson) {
+    const binary = packageJson.jongodb?.binary;
+    if (typeof binary !== "string") {
+        return null;
+    }
+    const normalized = binary.trim();
+    return normalized.length === 0 ? null : normalized;
+}
+function readBinEntryPath(value) {
+    if (typeof value === "string") {
+        const normalized = value.trim();
+        return normalized.length === 0 ? null : normalized;
+    }
+    if (value !== undefined && typeof value === "object") {
+        const preferred = value["jongodb-memory-server"];
+        if (typeof preferred === "string" && preferred.trim().length > 0) {
+            return preferred.trim();
+        }
+        for (const candidate of Object.values(value)) {
+            if (typeof candidate === "string" && candidate.trim().length > 0) {
+                return candidate.trim();
+            }
+        }
+    }
+    return null;
+}
+function bundledBinaryHint() {
+    const candidates = bundledBinaryPackageCandidates();
+    if (candidates.length === 0) {
+        return "Bundled platform binary package is not defined for this OS/architecture.";
+    }
+    return `Bundled platform binary package candidates: ${candidates.join(", ")}.`;
+}
+function resolveJavaCandidate(options) {
+    const classpath = resolveClasspathOrNull(options.classpath);
+    if (classpath === null) {
+        return null;
+    }
+    return {
+        javaPath: options.javaPath?.trim() || process.env.JONGODB_JAVA_PATH || "java",
+        classpath,
+        launcherClass: options.launcherClass?.trim() || DEFAULT_LAUNCHER_CLASS,
+        source: options.classpath !== undefined ? "options.classpath" : "JONGODB_CLASSPATH",
+    };
+}
+function normalizeTimeout(value, fallback, fieldName) {
+    const resolved = value ?? fallback;
+    if (!Number.isFinite(resolved) || resolved <= 0) {
+        throw new Error(`${fieldName} must be a positive number.`);
+    }
+    return Math.floor(resolved);
+}
+function normalizeHost(host) {
+    const normalized = host?.trim() || DEFAULT_HOST;
+    if (normalized.length === 0) {
+        throw new Error("host must not be empty.");
+    }
+    return normalized;
+}
+function normalizePort(port) {
+    const normalized = port ?? 0;
+    if (!Number.isInteger(normalized) || normalized < 0 || normalized > 65535) {
+        throw new Error("port must be an integer between 0 and 65535.");
+    }
+    return normalized;
+}
+function normalizeDatabaseName(databaseName) {
+    const normalized = databaseName?.trim() || DEFAULT_DATABASE;
+    if (normalized.length === 0) {
+        throw new Error("databaseName must not be empty.");
+    }
+    return normalized;
+}
+function resolveClasspathOrNull(classpath) {
+    const explicit = resolveExplicitClasspath(classpath);
+    if (explicit !== null) {
+        return explicit;
+    }
+    const fromEnv = process.env.JONGODB_CLASSPATH?.trim();
+    if (fromEnv !== undefined && fromEnv.length > 0) {
+        return fromEnv;
+    }
+    return null;
+}
+function resolveExplicitClasspath(classpath) {
+    if (typeof classpath === "string") {
+        const normalized = classpath.trim();
+        if (normalized.length === 0) {
+            throw new Error("classpath string is empty.");
+        }
+        return normalized;
+    }
+    if (Array.isArray(classpath)) {
+        if (classpath.length === 0) {
+            throw new Error("classpath array is empty.");
+        }
+        const normalizedParts = classpath
+            .map((part) => part.trim())
+            .filter((part) => part.length > 0);
+        if (normalizedParts.length === 0) {
+            throw new Error("classpath array has no valid entries.");
+        }
+        return normalizedParts.join(delimiter);
+    }
+    return null;
+}
+async function waitForStartup(params) {
+    const { child, stdoutReader, stderrReader, stdoutLines, stderrLines, startupTimeoutMs, logLevel, launchDescription, } = params;
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let resolvedUri = null;
+        const timeout = setTimeout(() => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            reject(new Error([
+                `Timed out waiting for jongodb startup after ${startupTimeoutMs}ms (${launchDescription}).`,
+                formatLogTail("stdout", stdoutLines),
+                formatLogTail("stderr", stderrLines),
+            ].join(" ")));
+        }, startupTimeoutMs);
+        const cleanupListeners = () => {
+            stdoutReader.off("line", onStdout);
+            stderrReader.off("line", onStderr);
+            child.off("error", onError);
+            child.off("exit", onExit);
+        };
+        const finish = (fn) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            cleanupListeners();
+            fn();
+        };
+        const onStdout = (line) => {
+            appendLine(stdoutLines, line);
+            maybeLog("stdout", line, logLevel);
+            if (!line.startsWith(READY_PREFIX)) {
+                return;
+            }
+            const uri = line.slice(READY_PREFIX.length).trim();
+            if (uri.length === 0) {
+                finish(() => reject(new Error("Launcher emitted empty JONGODB_URI line.")));
+                return;
+            }
+            resolvedUri = uri;
+            finish(() => resolve({ uri }));
+        };
+        const onStderr = (line) => {
+            appendLine(stderrLines, line);
+            maybeLog("stderr", line, logLevel);
+        };
+        const onError = (error) => {
+            finish(() => {
+                reject(new Error([
+                    `Failed to spawn launcher '${child.spawnfile}': ${error.message}`,
+                    `Launch source: ${launchDescription}.`,
+                    "Check binary/classpath configuration.",
+                ].join(" ")));
+            });
+        };
+        const onExit = (code, signal) => {
+            if (resolvedUri !== null) {
+                return;
+            }
+            finish(() => {
+                reject(new Error([
+                    `Jongodb process exited before readiness (code=${code}, signal=${signal}).`,
+                    `Launch source: ${launchDescription}.`,
+                    formatFailureLine(stderrLines),
+                    formatLogTail("stdout", stdoutLines),
+                    formatLogTail("stderr", stderrLines),
+                ].join(" ")));
+            });
+        };
+        stdoutReader.on("line", onStdout);
+        stderrReader.on("line", onStderr);
+        child.once("error", onError);
+        child.once("exit", onExit);
+    });
+}
+function maybeLog(stream, line, logLevel) {
+    if (logLevel === "silent") {
+        return;
+    }
+    if (logLevel === "info" && stream === "stdout") {
+        return;
+    }
+    if (stream === "stdout") {
+        // eslint-disable-next-line no-console
+        console.log(`[jongodb:${stream}] ${line}`);
+        return;
+    }
+    // eslint-disable-next-line no-console
+    console.error(`[jongodb:${stream}] ${line}`);
+}
+function appendLine(lines, line) {
+    lines.push(line);
+    if (lines.length > MAX_LOG_LINES) {
+        lines.shift();
+    }
+}
+function formatLogTail(name, lines) {
+    if (lines.length === 0) {
+        return `${name}:<empty>`;
+    }
+    return `${name}:` + lines.join(" | ");
+}
+function formatFailureLine(stderrLines) {
+    const failureLine = stderrLines.find((line) => line.startsWith(FAILURE_PREFIX));
+    if (failureLine === undefined) {
+        return "";
+    }
+    return failureLine;
+}
+async function forceStopIfAlive(child, stopTimeoutMs) {
+    if (child.exitCode !== null) {
+        return;
+    }
+    child.kill("SIGTERM");
+    const graceful = await waitForExit(child, stopTimeoutMs);
+    if (graceful !== null) {
+        return;
+    }
+    child.kill("SIGKILL");
+    await waitForExit(child, stopTimeoutMs);
+}
+function waitForExit(child, timeoutMs) {
+    if (child.exitCode !== null) {
+        return Promise.resolve({
+            code: child.exitCode,
+            signal: child.signalCode,
+        });
+    }
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            cleanup();
+            resolve(null);
+        }, timeoutMs);
+        const onExit = (code, signal) => {
+            cleanup();
+            resolve({ code, signal });
+        };
+        const cleanup = () => {
+            clearTimeout(timeout);
+            child.off("exit", onExit);
+        };
+        child.on("exit", onExit);
+    });
+}
+function wrapError(error) {
+    if (error instanceof Error) {
+        return error;
+    }
+    return new Error(String(error));
+}

package/dist/jest.d.ts

@@ -0,0 +1,31 @@
+import { type JongodbMemoryServerOptions } from "./index.js";
+export interface JestHookRegistrar {
+    beforeAll(callback: () => unknown | Promise<unknown>): void;
+    afterAll(callback: () => unknown | Promise<unknown>): void;
+}
+export interface JestHookOptions extends JongodbMemoryServerOptions {
+    envVarName?: string;
+}
+export interface RegisteredJongodbTestServer {
+    readonly uri: string;
+}
+export interface JestGlobalLifecycleOptions extends JongodbMemoryServerOptions {
+    envVarName?: string;
+    stateFile?: string;
+    killTimeoutMs?: number;
+}
+export interface JestGlobalState {
+    uri: string;
+    pid: number;
+    envVarName: string;
+}
+export declare function registerJongodbForJest(hooks: JestHookRegistrar, options?: JestHookOptions): RegisteredJongodbTestServer;
+export declare function createJestGlobalSetup(options?: JestGlobalLifecycleOptions): () => Promise<void>;
+export declare function createJestGlobalTeardown(options?: JestGlobalLifecycleOptions): () => Promise<void>;
+export declare function readJestGlobalState(options?: {
+    stateFile?: string;
+}): Promise<JestGlobalState | null>;
+export declare function readJestGlobalUri(options?: {
+    stateFile?: string;
+}): Promise<string | null>;
+//# sourceMappingURL=jest.d.ts.map

package/dist/jest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jest.d.ts","sourceRoot":"","sources":["../src/jest.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,KAAK,0BAA0B,EAEhC,MAAM,YAAY,CAAC;AAWpB,MAAM,WAAW,iBAAiB;IAChC,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,eAAgB,SAAQ,0BAA0B;IACjE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,0BAA2B,SAAQ,0BAA0B;IAC5E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,iBAAiB,EACxB,OAAO,GAAE,eAAoB,GAC5B,2BAA2B,CAgB7B;AAED,wBAAgB,qBAAqB,CACnC,OAAO,GAAE,0BAA+B,GACvC,MAAM,OAAO,CAAC,IAAI,CAAC,CAiBrB;AAED,wBAAgB,wBAAwB,CACtC,OAAO,GAAE,0BAA+B,GACvC,MAAM,OAAO,CAAC,IAAI,CAAC,CAkBrB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,GAAE;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAmBvC;AAED,wBAAsB,iBAAiB,CAAC,OAAO,GAAE;IAC/C,SAAS,CAAC,EAAE,MAAM,CAAC;CACf,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAM9B"}