@0q/embedded-mongodb 0.1.0

package/README.md

@@ -0,0 +1,35 @@
+# @0q/embedded-mongodb
+
+The MongoDB Node.js driver over an embedded MongoDB engine: the real server code, running
+inside your process against a local directory. No server, no port.
+
+```js
+const { MongoClient } = require('@0q/embedded-mongodb');
+
+const client = new MongoClient('mongodb_embedded://./data');
+const items = client.db('app').collection('items');
+await items.insertOne({ name: 'embedded' });
+console.log(await items.findOne());
+await client.close();
+```
+
+`MongoClient` is the driver's own class with one addition: a `mongodb_embedded://<directory>`
+(or `mongodb+embedded://`) address opens the directory in-process instead of connecting to a
+server. Any other address is handed to the driver untouched. The `mongodb` package is a peer
+dependency for this class; the lower layer needs nothing:
+
+```js
+const { open } = require('@0q/embedded-mongodb');
+
+const embedded = await open('./data');
+// embedded.uri is a mongodb:// address any driver in this process can connect to.
+await embedded.close();
+```
+
+Only one engine may be open per process. Linux x64, Linux arm64 and macOS arm64 are the
+supported platforms. Authentication, TLS, compression, sessions, transactions and change
+streams are not supported.
+
+Part of [embedded-mongo](https://github.com/jeroenvervaeke/embedded-mongo), which has the full
+documentation, the Python binding and the engine itself. Licensed under the SSPL-1.0, as
+MongoDB is.

package/index.d.ts

@@ -0,0 +1,35 @@
+import type { MongoClient as DriverMongoClient } from 'mongodb';
+
+export { Engine, RoundTrip } from './native';
+import type { Engine } from './native';
+
+/**
+ * The database directory an embedded URI (`mongodb_embedded://<dir>` or
+ * `mongodb+embedded://<dir>`) names, or `undefined` if this is not an embedded URI. Throws if
+ * the URI carries anything but a directory.
+ */
+export declare function pathFromUri(uri: unknown): string | undefined;
+
+/** An open data directory and the in-process listener serving it. */
+export declare class EmbeddedMongodb {
+  /** A `mongodb://` URI the driver can connect to. */
+  readonly uri: string;
+  readonly socketPath: string;
+  readonly engine: Engine;
+  /** Stops accepting connections, then closes the engine once every command in flight is done. */
+  close(): Promise<void>;
+  /** `close` for a caller with no loop to await on. */
+  closeSync(): void;
+}
+
+/** Opens `directory`, creating it if needed, and starts serving it. */
+export declare function open(directory: string): Promise<EmbeddedMongodb>;
+
+/** `open` for a caller with no loop to await on. Blocks for the length of the open. */
+export declare function openSync(directory: string): EmbeddedMongodb;
+
+/**
+ * The driver's `MongoClient`, accepting embedded URIs as well as the driver's own. Needs the
+ * `mongodb` package installed; everything else here works without it.
+ */
+export declare const MongoClient: typeof DriverMongoClient;

package/index.js

@@ -0,0 +1,227 @@
+'use strict';
+
+// The Node.js driver speaks OP_MSG to a socket, so the engine is given one: a listener on a
+// Unix socket in a private temporary directory, inside this process, that hands every message
+// it reads to the engine and writes the reply back. Nothing of the driver's is replaced or
+// reached into, which is what keeps this working across driver versions -- the driver sees a
+// standalone server at a socket path, and that is all it needs to see.
+
+const fs = require('node:fs');
+const net = require('node:net');
+const os = require('node:os');
+const path = require('node:path');
+
+const { Engine } = require('./native');
+
+const SCHEMES = ['mongodb+embedded://', 'mongodb_embedded://'];
+const OP_REPLY = 1;
+const OP_MSG = 2013;
+const HEADER_LENGTH = 16;
+
+/**
+ * The database directory an embedded URI names, or `undefined` if this is not an embedded URI.
+ * Answering `undefined` rather than throwing is what lets one client class serve both kinds of
+ * address: anything this does not recognise is passed to the driver untouched.
+ */
+function pathFromUri(uri) {
+  if (typeof uri !== 'string') return undefined;
+  for (const scheme of SCHEMES) {
+    if (!uri.startsWith(scheme)) continue;
+    const directory = uri.slice(scheme.length);
+    if (!directory || directory.includes('?') || directory.includes('#')) {
+      throw new Error('embedded MongoDB URI must contain only a database directory');
+    }
+    return decodeURIComponent(directory);
+  }
+  return undefined;
+}
+
+/** An open directory and the listener serving it. `uri` is what to hand the driver. */
+class EmbeddedMongodb {
+  #engine;
+  #server;
+  #sockets = new Set();
+  #directory;
+  #closed = false;
+
+  constructor(engine) {
+    this.#engine = engine;
+    // mkdtemp creates the directory 0700, so the socket is reachable by this user alone.
+    this.#directory = fs.mkdtempSync(path.join(os.tmpdir(), 'embedded-mongodb-'));
+    this.socketPath = path.join(this.#directory, 'mongodb.sock');
+    this.uri = `mongodb://${encodeURIComponent(this.socketPath)}/?directConnection=true`;
+    this.#server = net.createServer((socket) => {
+      this.#sockets.add(socket);
+      socket.on('close', () => this.#sockets.delete(socket));
+      serve(engine, socket);
+    });
+    // Binding a Unix socket happens synchronously inside listen(), so the path exists and
+    // accepts connections by the time this returns; only the 'listening' event is deferred.
+    this.#server.listen(this.socketPath);
+  }
+
+  get engine() {
+    return this.#engine;
+  }
+
+  /** Stops accepting connections, then closes the engine once every command in flight is done. */
+  async close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    await new Promise((resolve) => {
+      this.#server.close(() => resolve());
+      for (const socket of this.#sockets) socket.destroy();
+    });
+    try {
+      await this.#engine.close();
+    } finally {
+      fs.rmSync(this.#directory, { recursive: true, force: true });
+    }
+  }
+
+  /** `close` for a caller with no loop to await on, such as a constructor undoing its open. */
+  closeSync() {
+    if (this.#closed) return;
+    this.#closed = true;
+    for (const socket of this.#sockets) socket.destroy();
+    this.#server.close();
+    try {
+      this.#engine.closeSync();
+    } finally {
+      fs.rmSync(this.#directory, { recursive: true, force: true });
+    }
+  }
+}
+
+/** Opens `directory` -- creating it if needed -- and starts serving it. */
+async function open(directory) {
+  return new EmbeddedMongodb(await Engine.open(directory));
+}
+
+/** `open` for a caller with no loop to await on. Blocks for the length of the open. */
+function openSync(directory) {
+  return new EmbeddedMongodb(Engine.openSync(directory));
+}
+
+/**
+ * One connection. Messages are answered in the order they arrive, which is the order the
+ * driver awaits them in: it never pipelines on one connection, and runs commands in parallel
+ * by opening more connections -- each of which lands here separately, and reaches the engine's
+ * strand pool alongside the others.
+ */
+function serve(engine, socket) {
+  let pending = Buffer.alloc(0);
+  let queue = Promise.resolve();
+  let replyId = 0;
+
+  const answer = async (message) => {
+    const { requestId, moreToCome, legacy, response } = await engine.roundTrip(message);
+    if (moreToCome || socket.destroyed) return;
+    const frame = legacy ? replyFrame(response) : msgFrame(response);
+    frame.writeInt32LE(frame.length, 0);
+    frame.writeInt32LE(++replyId, 4);
+    frame.writeInt32LE(requestId, 8);
+    socket.write(frame);
+  };
+
+  socket.on('data', (chunk) => {
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const length = pending.readInt32LE(0);
+      if (length < HEADER_LENGTH) {
+        socket.destroy(new Error(`invalid wire message length ${length}`));
+        return;
+      }
+      if (pending.length < length) break;
+      const message = pending.subarray(0, length);
+      pending = pending.subarray(length);
+      // A failure here is the connection's, as it would be on a real socket: the driver sees
+      // it dropped, with the reason, rather than a reply it cannot match to a request.
+      queue = queue.then(() => answer(message)).catch((error) => socket.destroy(error));
+    }
+  });
+  // The driver closes connections it is done with, and destroys them on error; neither is
+  // anything this side needs to act on beyond the 'close' bookkeeping above.
+  socket.on('error', () => {});
+}
+
+/** An OP_MSG carrying one body section. The header's length and ids are filled in by the caller. */
+function msgFrame(body) {
+  const frame = Buffer.allocUnsafe(HEADER_LENGTH + 5 + body.length);
+  frame.writeInt32LE(OP_MSG, 12);
+  frame.writeUInt32LE(0, 16); // flag bits: a plain reply, nothing more to come
+  frame.writeUInt8(0, 20); // section kind: body
+  body.copy(frame, HEADER_LENGTH + 5);
+  return frame;
+}
+
+/** An OP_REPLY carrying one document: what an OP_QUERY handshake is answered with. */
+function replyFrame(body) {
+  const frame = Buffer.allocUnsafe(HEADER_LENGTH + 20 + body.length);
+  frame.writeInt32LE(OP_REPLY, 12);
+  frame.writeInt32LE(0, 16); // response flags
+  frame.writeBigInt64LE(0n, 20); // cursor id
+  frame.writeInt32LE(0, 28); // starting from
+  frame.writeInt32LE(1, 32); // number returned
+  body.copy(frame, HEADER_LENGTH + 20);
+  return frame;
+}
+
+/**
+ * The driver's `MongoClient`, with embedded URIs routed to the in-process engine. Built on
+ * first use rather than at load, so the package loads -- and `open` works -- without the
+ * driver installed.
+ */
+let client;
+function mongoClient() {
+  if (client) return client;
+  let driver;
+  try {
+    driver = require('mongodb');
+  } catch (error) {
+    throw new Error('MongoClient needs the mongodb package installed alongside @0q/embedded-mongodb', {
+      cause: error,
+    });
+  }
+  client = class MongoClient extends driver.MongoClient {
+    #embedded;
+
+    constructor(uri, options) {
+      const directory = pathFromUri(uri);
+      if (directory === undefined) {
+        super(uri, options);
+        return;
+      }
+      // Synchronously, because this is a constructor in the driver's API: the engine has to be
+      // serving by the time `connect` can be called, and there is nothing here to await.
+      const embedded = openSync(directory);
+      try {
+        super(embedded.uri, options);
+      } catch (error) {
+        embedded.closeSync();
+        throw error;
+      }
+      this.#embedded = embedded;
+    }
+
+    async close(force) {
+      try {
+        await super.close(force);
+      } finally {
+        await this.#embedded?.close();
+      }
+    }
+  };
+  return client;
+}
+
+module.exports = {
+  Engine,
+  EmbeddedMongodb,
+  open,
+  openSync,
+  pathFromUri,
+  get MongoClient() {
+    return mongoClient();
+  },
+};

package/native.d.ts

@@ -0,0 +1,46 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/**
+ * An open data directory. One per process: the engine keeps a single runtime, and opening a
+ * second directory before the first is closed is refused with a message saying so.
+ */
+export declare class Engine {
+  /**
+   * Opens the directory, creating it if it does not exist. Also runs the one-time index
+   * repair pass over a directory an older build damaged, which is a scan of every
+   * collection in it -- the longest thing this package ever does.
+   */
+  static open(path: string): Promise<Engine>
+  /**
+   * [`Engine::open`] for a caller with no loop to await on: `new MongoClient(...)` is a
+   * constructor in the driver's API, and the engine has to be up before it returns.
+   */
+  static openSync(path: string): Engine
+  /**
+   * Runs one OP_MSG and answers the reply. Commands from other connections run alongside
+   * this one -- the read guard is shared -- and only [`Engine::close`] excludes them.
+   */
+  roundTrip(message: Buffer): Promise<RoundTrip>
+  /**
+   * Closes the engine, waiting for the commands other connections are still running. The
+   * write guard is a temporary of the first statement, so the engine's own shutdown runs
+   * with the lock released, and a command arriving meanwhile is told the engine is closed.
+   */
+  close(): Promise<void>
+  /**
+   * [`Engine::close`] for the one caller with no loop to await on: `new MongoClient(...)`
+   * undoing its own open when the rest of the constructor fails. Leaving the engine open
+   * there would cost the process its one runtime, and every later open would be refused.
+   */
+  closeSync(): void
+}
+
+/** One reply, alongside what the listener needs to frame it. */
+export interface RoundTrip {
+  requestId: number
+  /** The request's flag: a driver that set it wants no reply written. */
+  moreToCome: boolean
+  /** The request was an OP_QUERY, so the reply has to be framed as an OP_REPLY. */
+  legacy: boolean
+  response: Buffer
+}

package/native.js

@@ -0,0 +1,703 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (process.report && typeof process.report.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./embedded-mongodb.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-android-arm64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./embedded-mongodb.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-android-arm-eabi')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if ((process.config && process.config.variables && process.config.variables.shlib_suffix === 'dll.a') || (process.config && process.config.variables && process.config.variables.node_target_type === 'shared_library')) {
+        try {
+        return require('./embedded-mongodb.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-win32-x64-gnu')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./embedded-mongodb.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-win32-x64-msvc')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./embedded-mongodb.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-win32-ia32-msvc')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./embedded-mongodb.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-win32-arm64-msvc')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./embedded-mongodb.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@0q/embedded-mongodb-darwin-universal')
+      const bindingPackageVersion = require('@0q/embedded-mongodb-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./embedded-mongodb.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-darwin-x64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./embedded-mongodb.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-darwin-arm64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./embedded-mongodb.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-freebsd-x64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./embedded-mongodb.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-freebsd-arm64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./embedded-mongodb.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-x64-musl')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./embedded-mongodb.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-x64-gnu')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./embedded-mongodb.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-arm64-musl')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./embedded-mongodb.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-arm64-gnu')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./embedded-mongodb.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./embedded-mongodb.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./embedded-mongodb.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-loong64-musl')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./embedded-mongodb.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-loong64-gnu')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./embedded-mongodb.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-riscv64-musl')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./embedded-mongodb.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@0q/embedded-mongodb-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@0q/embedded-mongodb-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./embedded-mongodb.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./embedded-mongodb.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-linux-s390x-gnu')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./embedded-mongodb.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-openharmony-arm64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./embedded-mongodb.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-openharmony-x64')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./embedded-mongodb.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@0q/embedded-mongodb-openharmony-arm')
+        const bindingPackageVersion = require('@0q/embedded-mongodb-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+function createLoadErrorChain(errors) {
+  return errors.reduce((previous, current) => {
+    let message
+    try {
+      message =
+        current && typeof current.message === 'string'
+          ? current.message
+          : String(current)
+    } catch {
+      message = 'Unknown error'
+    }
+    const error = new Error(message)
+    error.cause = previous
+    return error
+  }, null)
+}
+
+// NAPI_RS_FORCE_WASI is a tri-state flag:
+//   unset / any other value → native binding preferred, WASI is only a fallback
+//   'true'                   → prefer WASI, but retain native as a lazy fallback
+//   'error'                  → require WASI without initializing a native fallback
+// Treating any non-empty string as truthy (the historical behavior) meant
+// NAPI_RS_FORCE_WASI=false, NAPI_RS_FORCE_WASI=0, etc. inadvertently triggered
+// the WASI path, causing ENOENT for packages shipped without a .wasi.cjs file.
+//
+// NAPI_RS_WASI_FLAVOR selects one exact generated flavor and implies strict
+// WASI loading. It never crosses into another flavor or falls back to native.
+const __napiWasiFlavors = ["wasm32-wasi"]
+const __napiWasiFlavor = process.env.NAPI_RS_WASI_FLAVOR
+const __napiWasiFlavorRequested =
+  typeof __napiWasiFlavor === 'string' && __napiWasiFlavor.length > 0
+if (
+  __napiWasiFlavorRequested &&
+  __napiWasiFlavors.indexOf(__napiWasiFlavor) === -1
+) {
+  throw new Error(
+    'Unsupported WASI flavor "' +
+      __napiWasiFlavor +
+      '". Available flavors: ' +
+      __napiWasiFlavors.join(', '),
+  )
+}
+const forceWasiError = process.env.NAPI_RS_FORCE_WASI === 'error'
+const forceWasi =
+  process.env.NAPI_RS_FORCE_WASI === 'true' ||
+  forceWasiError ||
+  __napiWasiFlavorRequested
+
+if (!forceWasi) {
+  nativeBinding = requireNative()
+}
+
+if (!nativeBinding || forceWasi) {
+  let wasiBinding = null
+  let wasiBindingLoaded = false
+  const wasiBindingErrors = []
+  const __napiWasiResolveCandidate = (specifier, isPackage, localArtifacts) => {
+    try {
+      require.resolve(specifier)
+    } catch (resolveError) {
+      if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+        throw resolveError
+      }
+      if (isPackage) {
+        try {
+          require.resolve(specifier + '/package.json')
+        } catch (packageError) {
+          if (packageError && packageError.code === 'MODULE_NOT_FOUND') {
+            return resolveError
+          }
+          // An exports restriction proves the package exists even when its
+          // package.json is not public. Preserve the root resolution failure.
+          throw resolveError
+        }
+        // The package exists but its main/export target is broken.
+        throw resolveError
+      }
+      return resolveError
+    }
+    if (localArtifacts) {
+      let artifactError = null
+      for (let i = 0; i < localArtifacts.length; i++) {
+        try {
+          require.resolve(localArtifacts[i])
+          return null
+        } catch (resolveError) {
+          if (!resolveError || resolveError.code !== 'MODULE_NOT_FOUND') {
+            throw resolveError
+          }
+          artifactError = resolveError
+        }
+      }
+      return artifactError
+    }
+    return null
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('./embedded-mongodb.wasi.cjs', false, ["./embedded-mongodb.wasm32-wasi.debug.wasm","./embedded-mongodb.wasm32-wasi.wasm"])
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        wasiBinding = require('./embedded-mongodb.wasi.cjs')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (!wasiBindingLoaded && (!__napiWasiFlavorRequested || __napiWasiFlavor === "wasm32-wasi")) {
+    let candidateError = null
+    let candidateFailed = false
+    try {
+      candidateError = __napiWasiResolveCandidate('@0q/embedded-mongodb-wasm32-wasi', true, undefined)
+      candidateFailed = candidateError !== null
+      if (!candidateFailed) {
+        if (process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          const bindingPackageVersion = require('@0q/embedded-mongodb-wasm32-wasi/package.json').version
+          if (bindingPackageVersion !== '0.1.0') {
+            throw new Error(`WASI binding package version mismatch, expected 0.1.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+        }
+        wasiBinding = require('@0q/embedded-mongodb-wasm32-wasi')
+        nativeBinding = wasiBinding
+        wasiBindingLoaded = true
+      }
+    } catch (err) {
+      candidateError = err
+      candidateFailed = true
+    }
+    if (candidateFailed) {
+      wasiBindingErrors.push(candidateError)
+      loadErrors.push(candidateError)
+    }
+  }
+  if (
+    !wasiBindingLoaded &&
+    forceWasi &&
+    !forceWasiError &&
+    !__napiWasiFlavorRequested
+  ) {
+    nativeBinding = requireNative()
+  }
+  if ((forceWasiError || __napiWasiFlavorRequested) && !wasiBindingLoaded) {
+    const error = new Error(
+      __napiWasiFlavorRequested
+        ? 'WASI binding for flavor "' + __napiWasiFlavor + '" not found'
+        : 'WASI binding not found and NAPI_RS_FORCE_WASI is set to error',
+    )
+    error.cause = createLoadErrorChain(wasiBindingErrors)
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    const error = new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+    )
+    // assign instead of the `new Error(message, { cause })` options form,
+    // which Node < 16.9 silently ignores
+    error.cause = createLoadErrorChain(loadErrors)
+    throw error
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.Engine = nativeBinding.Engine

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@0q/embedded-mongodb",
+  "version": "0.1.0",
+  "description": "Run the MongoDB Node.js driver against an in-process embedded MongoDB engine",
+  "license": "SSPL-1.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jeroenvervaeke/embedded-mongo.git",
+    "directory": "embedded-mongodb-node"
+  },
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "native.js",
+    "native.d.ts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">= 20"
+  },
+  "napi": {
+    "binaryName": "embedded-mongodb",
+    "targets": [
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-apple-darwin"
+    ]
+  },
+  "scripts": {
+    "build": "napi build --platform --release --js native.js --dts native.d.ts && node scripts/bundle-engine.js",
+    "test": "node --test test/*.test.js"
+  },
+  "peerDependencies": {
+    "mongodb": ">=6"
+  },
+  "peerDependenciesMeta": {
+    "mongodb": {
+      "optional": true
+    }
+  },
+  "optionalDependencies": {
+    "@0q/embedded-mongodb-linux-x64-gnu": "0.1.0",
+    "@0q/embedded-mongodb-linux-arm64-gnu": "0.1.0",
+    "@0q/embedded-mongodb-darwin-arm64": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.9.0",
+    "mongodb": "^7.5.0"
+  }
+}