jsql-neo 5.2.0 → 5.2.1

package/README.md

@@ -1,10 +1,13 @@
 # JSQL-NEO
 
 > **One engine to rule them all** — a Rust-powered embedded database that speaks your language:
-> MySQL protocol. Redis protocol. SQL. TypeScript. The browser. **And it fits in one npm package.**
+> MySQL protocol. PostgreSQL protocol. Redis protocol. SQL. TypeScript. The browser. **And it fits in one npm package.**
+
+> **v5.2.1** — official release build · [github.com/vexify-org/JSQL-neo](https://github.com/vexify-org/JSQL-neo)
 
 ![Engines](https://img.shields.io/badge/engines-Native%20%7C%20WASM%20%7C%20Pure%20JS-7ee787)
 ![MySQL](https://img.shields.io/badge/protocol-MySQL%20compatible-1f6feb)
+![PostgreSQL](https://img.shields.io/badge/protocol-PostgreSQL%20compatible-336791)
 ![Redis](https://img.shields.io/badge/protocol-Redis%20RESP2-f03c15)
 ![ZERO](https://img.shields.io/badge/dependencies-ZERO-8957e5)
 ![WASM](https://img.shields.io/badge/runs%20in-Browser%20%28WASM%29-79c0ff)
@@ -20,6 +23,7 @@ database protocols in the world**.
 - ⚡ **Rust core** — N-API native addon, ~2× faster than better-sqlite3 (see [Benchmark](#benchmark))
 - 🧩 **WASM build** — the *same engine* runs in Node.js **and any browser**, zero native deps
 - 🐘 **MySQL protocol** — Sequelize, Knex, TypeORM, mysql2, phpMyAdmin … **just work**, no plugin
+- 🐘 **PostgreSQL protocol** — node-postgres, psql, pgAdmin — SCRAM-SHA-256 auth, prepared statements, JSONB, ILIKE, `ON CONFLICT`, SERIAL/BIGSERIAL auto-increment
 - 🐇 **Redis protocol** — ioredis, node-redis, redis-cli — strings, hashes, lists, sets, TTL, snapshots
 - 🌐 **Built-in Web UI** — a zero-dependency management console ships with the package
 - 🗃️ **Three storage modes** — memory-first, hybrid (LRU + async flush), and disk
@@ -170,6 +174,30 @@ createMysqlServer({
 
 ---
 
+## Speak PostgreSQL
+
+A PostgreSQL wire-protocol (v3) server that accepts **standard PostgreSQL clients** — `node-postgres`,
+`psql`, `pgAdmin` — with SCRAM-SHA-256 authentication and per-database ACL.
+
+| Feature | Support |
+|---------|---------|
+| Wire protocol v3 (simple + extended query) | ✅ |
+| SCRAM-SHA-256 / MD5 / cleartext authentication | ✅ |
+| Prepared statements (Parse / Bind / Describe / Execute / Sync) | ✅ |
+| Transactions (BEGIN / COMMIT / ROLLBACK) | ✅ |
+| JSONB columns | ✅ |
+| `ILIKE` (case-insensitive LIKE) | ✅ |
+| `ON CONFLICT DO NOTHING` | ✅ |
+| `SERIAL` / `BIGSERIAL` → auto-increment | ✅ |
+| SQLSTATE error mapping（缺表 → `42P01` 等） | ✅ |
+
+```bash
+jsql serve --pg -p 5432 --data-dir ./data
+psql -h 127.0.0.1 -p 5432 -U postgres        # any PostgreSQL client, now
+```
+
+---
+
 ## Speak Redis
 
 A RESP2 server that plays perfectly with `ioredis`, `node-redis`, and `redis-cli`:

package/lib/database.js

@@ -1350,7 +1350,8 @@ class Database {
             for (const id of ids) removed += table.removeById(id);
         } else {
             for (const id of ids) {
-                const idx = table._rows.findIndex(r => r === this._resolveId(table, id));
+                const row = this._resolveId(table, id);
+                const idx = row ? table._rows.findIndex(r => r === row) : -1;
                 if (idx !== -1) {
                     table._rows.splice(idx, 1);
                     removed++;
@@ -1366,6 +1367,24 @@ class Database {
         return { ok: true, count: removed };
     }
 
+    removeWhere(tableName, filter) {
+        const table = this._ensureTable(tableName);
+        if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);
+        if (!this._runHooks('beforeDelete', [tableName, [filter]])) return { ok: true, count: 0 };
+        const before = table._rows.length;
+        const matched = table._applyFilter(table._rows, filter || {});
+        const matchSet = new Set(matched);
+        table._rows = table._rows.filter(r => !matchSet.has(r));
+        const removed = before - table._rows.length;
+        table._rebuildPKIndex();
+        table._rebuildAllBTrees();
+        for (const field of Object.keys(table._indexes)) table.createIndex(field);
+        this._emit('delete', { table: tableName, ids: [], result: { ok: true, count: removed } });
+        this._runHooks('afterDelete', [tableName, [filter], { ok: true, count: removed }]);
+        this._markDirty(tableName);
+        return { ok: true, count: removed };
+    }
+
     insertMany(tableName, items) {
         const table = this._ensureTable(tableName);
         if (!table) throw createError('ER_NO_SUCH_TABLE', tableName);

package/lib/mongo_server.js

@@ -0,0 +1,483 @@
+/*
+ * MongoDB wire protocol (OP_MSG, 3.6+) server for JSQL-NEO.
+ *
+ * Lets the official `mongodb` npm driver (and mongosh / Compass) connect to
+ * jsql-neo as if it were a MongoDB server. Documents are stored as rows of a
+ * JSQL table named after the MongoDB collection.
+ *
+ * Commands supported (minimal but practical):
+ *   hello / isMaster / ping / buildInfo / getParameter / endSessions
+ *   listDatabases / listCollections / create / drop
+ *   insert / find / getMore / update / delete / count / aggregate($match,$count)
+ */
+const net = require('net');
+const path = require('path');
+const zlib = require('zlib');
+const Database = require('./database');
+
+const OP_MSG = 2013;
+const OP_COMPRESSED = 2012;
+const OP_QUERY = 2004;
+const OP_REPLY = 1;
+
+/* ------------------------------------------------------------------ */
+/* BSON                                                               */
+/* ------------------------------------------------------------------ */
+
+function appendBytes(buf, b) {
+  const out = Buffer.concat([buf, b]);
+  return out;
+}
+
+function bsonDocument(obj) {
+  // 简易 BSON 文档编码（定长后修正 size）
+  let body = Buffer.alloc(4); // size placeholder
+  for (const [k, v] of Object.entries(obj || {})) {
+    const name = Buffer.from(k, 'utf8');
+    if (v === null || v === undefined) {
+      body = Buffer.concat([body, Buffer.from([0x0A]), name, Buffer.from([0])]);
+      continue;
+    }
+    if (typeof v === 'number') {
+      const b = Buffer.alloc(8);
+      b.writeDoubleLE(v, 0);
+      body = Buffer.concat([body, Buffer.from([0x01]), name, Buffer.from([0]), b]);
+      continue;
+    }
+    if (v && v.$long !== undefined) {
+      const b = Buffer.alloc(8);
+      b.writeBigInt64LE(BigInt(Math.trunc(Number(v.$long))), 0);
+      body = Buffer.concat([body, Buffer.from([0x12]), name, Buffer.from([0]), b]);
+      continue;
+    }
+    if (typeof v === 'boolean') {
+      body = Buffer.concat([body, Buffer.from([0x08]), name, Buffer.from([0]), Buffer.from([v ? 1 : 0])]);
+      continue;
+    }
+    if (typeof v === 'string') {
+      const str = Buffer.from(v, 'utf8');
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(str.length + 1, 0);
+      body = Buffer.concat([body, Buffer.from([0x02]), name, Buffer.from([0]), lenBuf, str, Buffer.from([0])]);
+      continue;
+    }
+    if (Buffer.isBuffer(v)) {
+      const lenBuf = Buffer.alloc(4);
+      lenBuf.writeInt32LE(v.length, 0);
+      body = Buffer.concat([body, Buffer.from([0x05]), name, Buffer.from([0]), lenBuf, Buffer.from([0, v.buffer ? 0 : 0]), v]);
+      continue;
+    }
+    if (v instanceof Date) {
+      const b = Buffer.alloc(8);
+      b.writeBigInt64LE(BigInt(v.getTime()), 0);
+      body = Buffer.concat([body, Buffer.from([0x09]), name, Buffer.from([0]), b]);
+      continue;
+    }
+    if (Array.isArray(v)) {
+      const arrObj = {};
+      v.forEach((x, i) => { arrObj[String(i)] = x; });
+      const sub = bsonDocument(arrObj);
+      body = Buffer.concat([body, Buffer.from([0x04]), name, Buffer.from([0]), sub]);
+      continue;
+    }
+    if (typeof v === 'object') {
+      const sub = bsonDocument(v);
+      body = Buffer.concat([body, Buffer.from([0x03]), name, Buffer.from([0]), sub]);
+      continue;
+    }
+    // fallback: int32
+    const b = Buffer.alloc(4);
+    b.writeInt32LE(Number(v) || 0, 0);
+    body = Buffer.concat([body, Buffer.from([0x10]), name, Buffer.from([0]), b]);
+  }
+  body = Buffer.concat([body, Buffer.from([0])]);
+  body.writeInt32LE(body.length, 0);
+  return body;
+}
+
+function bsonReadDocument(buf, pos) {
+  const start = pos;
+  const size = buf.readInt32LE(pos); pos += 4;
+  const end = start + size;
+  const obj = {};
+  while (pos < end - 1) {
+    const type = buf[pos++];
+    // cstring field name
+    const nameEnd = buf.indexOf(0, pos);
+    const name = buf.toString('utf8', pos, nameEnd);
+    pos = nameEnd + 1;
+    const r = bsonReadValue(buf, pos, type, end);
+    obj[name] = r.value;
+    pos = r.pos;
+  }
+  return { value: obj, pos: end };
+}
+
+function bsonReadValue(buf, pos, type, end) {
+  switch (type) {
+    case 0x01: { const v = buf.readDoubleLE(pos); return { value: v, pos: pos + 8 }; }
+    case 0x02: {
+      const len = buf.readInt32LE(pos); pos += 4;
+      const v = buf.toString('utf8', pos, pos + len - 1);
+      return { value: v, pos: pos + len };
+    }
+    case 0x03: { const r = bsonReadDocument(buf, pos); return { value: r.value, pos: r.pos }; }
+    case 0x04: {
+      const r = bsonReadDocument(buf, pos);
+      const arr = [];
+      for (let i = 0; i < Object.keys(r.value).length; i++) arr.push(r.value[String(i)]);
+      return { value: arr, pos: r.pos };
+    }
+    case 0x05: { const len = buf.readInt32LE(pos); return { value: buf.slice(pos + 5, pos + 5 + len), pos: pos + 5 + len }; }
+    case 0x07: { return { value: buf.slice(pos, pos + 12).toString('hex'), pos: pos + 12 }; }
+    case 0x08: { return { value: buf[pos] !== 0, pos: pos + 1 }; }
+    case 0x09: { return { value: new Date(Number(buf.readBigInt64LE(pos))), pos: pos + 8 }; }
+    case 0x0A: { return { value: null, pos }; }
+    case 0x10: { return { value: buf.readInt32LE(pos), pos: pos + 4 }; }
+    case 0x11: { return { value: Number(buf.readBigInt64LE(pos)), pos: pos + 8 }; }
+    case 0x12: { return { value: Number(buf.readBigInt64LE(pos)), pos: pos + 8 }; }
+    case 0x13: { return { value: buf.readDoubleLE(pos + 1), pos: pos + 17 }; }
+    default: return { value: null, pos: end };
+  }
+}
+
+/* ------------------------------------------------------------------ */
+/* Server                                                             */
+/* ------------------------------------------------------------------ */
+
+class MongoServer {
+  constructor(options = {}) {
+    this.options = options;
+    this.port = options.port || 27017;
+    this.host = options.host || '127.0.0.1';
+    this.dataDir = options.dataDir || null;
+    this._engine = null;
+    this._server = null;
+    this._sockets = new Set();
+  }
+
+  async _getEngine() {
+    if (this._engine) return this._engine;
+    if (this.dataDir && this.dataDir !== ':memory:') {
+      this._engine = new Database(path.join(this.dataDir, 'default'), { autoSave: true });
+    } else {
+      this._engine = new Database(':memory:', { autoSave: false });
+    }
+    return this._engine;
+  }
+
+  async _ensureCollection(name) {
+    const engine = await this._getEngine();
+    if (!engine.getTableSchema(name)) {
+      engine.createTable(name, {});
+    }
+    return engine;
+  }
+
+  listen(cb) {
+    this._server = net.createServer((socket) => this._handleSocket(socket));
+    this._server.listen(this.port, this.host, cb || (() => {}));
+    return this;
+  }
+
+  _handleSocket(socket, existing) {
+    this._sockets.add(socket);
+    socket.on('close', () => this._sockets.delete(socket));
+    let buf = Buffer.isBuffer(existing) ? Buffer.from(existing) : Buffer.alloc(0);
+    socket.on('error', () => {});
+    const process = async () => {
+      for (;;) {
+        if (buf.length < 4) break;
+        const len = buf.readInt32LE(0);
+        if (len < 16 || buf.length < len) break;
+        const msg = buf.slice(0, len);
+        buf = buf.slice(len);
+        try {
+          await this._handleMessage(socket, msg);
+        } catch (e) {
+          try { socket.write(this._wrapMsg(bsonDocument({ ok: 0, errmsg: e.message || String(e) }), this._reqId(msg))); } catch (_) {}
+        }
+      }
+    };
+    socket.on('data', async (chunk) => {
+      buf = Buffer.concat([buf, chunk]);
+      await process();
+    });
+    if (buf.length > 0) process();
+  }
+
+  _reqId(msg) {
+    return msg.readInt32LE(4);
+  }
+
+  _wrapMsg(payload, responseTo) {
+    const id = Math.floor(Math.random() * 0x7fffffff);
+    const head = Buffer.alloc(16);
+    head.writeInt32LE(16 + 4 + 1 + payload.length, 0); // messageLength
+    head.writeInt32LE(id, 4);                      // requestID
+    head.writeInt32LE(responseTo, 8);              // responseTo
+    head.writeInt32LE(OP_MSG, 12);                 // opCode
+    const flags = Buffer.alloc(4);
+    return Buffer.concat([head, flags, Buffer.from([0x00]), payload]); // flagBits + kind0
+  }
+
+  _wrapReply(payload, requestId) {
+    // OP_REPLY: header + responseFlags + cursorID + startingFrom + numberReturned + documents
+    const n = 16 + 4 + 8 + 4 + 4 + payload.length;
+    const head = Buffer.alloc(16);
+    head.writeInt32LE(n, 0);
+    head.writeInt32LE(requestId + 1000, 4);
+    head.writeInt32LE(requestId, 8);
+    head.writeInt32LE(OP_REPLY, 12);
+    const rest = Buffer.alloc(4 + 8 + 4 + 4); // responseFlags=0, cursorID=0, startingFrom=0, numberReturned=1
+    rest.writeInt32LE(1, 4 + 8 + 4);
+    return Buffer.concat([head, rest, payload]);
+  }
+
+  async _handleMessage(socket, msg) {
+    const op = msg.readInt32LE(12);
+    if (op === OP_QUERY) {
+      let p = 20; // header + flags
+      while (p < msg.length && msg[p] !== 0) p++;
+      const ns = msg.toString('utf8', 20, p);
+      p = p + 1 + 8; // null terminator + numberToSkip + numberToReturn
+      if (p >= msg.length || !ns.endsWith('.$cmd')) {
+        socket.write(this._wrapReply(bsonDocument({ ok: 0, errmsg: 'legacy op only supports $cmd' }), this._reqId(msg)));
+        return;
+      }
+      try {
+        const body = bsonReadDocument(msg, p).value;
+        const command = this._commandName(body);
+        const reply = await this._dispatch(command, body);
+        socket.write(this._wrapReply(bsonDocument(reply), this._reqId(msg)));
+      } catch (e) {
+        socket.write(this._wrapReply(bsonDocument({ ok: 0, errmsg: e.message || String(e) }), this._reqId(msg)));
+      }
+      return;
+    }
+    if (op === OP_COMPRESSED) {
+      msg = this._decompress(msg);
+    }
+    if (!msg) {
+      socket.write(this._wrapMsg(bsonDocument({ ok: 0, errmsg: 'compression not supported' }), this._reqId(msg || Buffer.alloc(16))));
+      return;
+    }
+    const op2 = msg.readInt32LE(12);
+    if (op2 !== OP_MSG) {
+      socket.write(this._wrapMsg(bsonDocument({ ok: 0, errmsg: `opCode ${op2} not supported` }), this._reqId(msg)));
+      return;
+    }
+    let pos = 16 + 4; // header + flagBits
+    const kind = msg[pos]; pos++; // section kind: 0 = single BSON doc
+    if (kind !== 0) {
+      socket.write(this._wrapMsg(bsonDocument({ ok: 0, errmsg: `section kind ${kind} not supported` }), this._reqId(msg)));
+      return;
+    }
+    const body = bsonReadDocument(msg, pos).value;
+    const command = this._commandName(body);
+    const reply = await this._dispatch(command, body);
+    socket.write(this._wrapMsg(bsonDocument(reply), this._reqId(msg)));
+  }
+
+  _commandName(doc) {
+    for (const k of Object.keys(doc)) {
+      if (k === '$db' || k === 'lsid' || k === '$clusterTime' || k === '$readPreference' || k === 'readConcern' || k === 'writeConcern') continue;
+      return k;
+    }
+    return 'ping';
+  }
+
+  _decompress(msg) {
+    try {
+      const origOp = msg.readInt32LE(16);
+      const uncompSize = msg.readInt32LE(20);
+      const compId = msg[24];
+      const data = msg.slice(25);
+      let out;
+      if (compId === 2) out = zlib.inflateSync(data);          // zlib
+      else if (compId === 3) { /* zstd 无内置支持 */ return null; }
+      else if (compId === 1) { /* snappy 无内置支持 */ return null; }
+      else return null;
+      const head = Buffer.from(msg.slice(0, 16));
+      head.writeInt32LE(origOp, 12);
+      return Buffer.concat([head, out]);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  _dbOf(doc, fallback = 'test') {
+    return doc.$db || fallback;
+  }
+
+  async _dispatch(cmd, doc) {
+
+    switch (cmd) {
+      case 'hello':
+      case 'isMaster':
+      case 'ismaster':
+        return {
+          ok: 1, isWritablePrimary: true, helloOk: true, maxWireVersion: 17, minWireVersion: 0,
+          maxBsonObjectSize: 16777216, maxMessageSizeBytes: 48000000, maxWriteBatchSize: 100000,
+          localTime: new Date(), logicalSessionTimeoutMinutes: 30, connectionId: 1,
+        };
+      case 'ping': return { ok: 1 };
+      case 'buildInfo': return { ok: 1, version: '5.2.1-jsql-neo', gitVersion: 'jsql-neo', versionArray: [5, 2, 1, 0] };
+      case 'getParameter': return { ok: 1 };
+      case 'endSessions': return { ok: 1 };
+      case 'listDatabases':
+        return { ok: 1, databases: [{ name: this._dbOf(doc), sizeOnDisk: 1, empty: false }], totalSize: 1 };
+      case 'listCollections': {
+        const engine = await this._getEngine();
+        const tables = Object.keys(engine._meta && engine._meta.tables ? engine._meta.tables : (engine._tables || {}));
+        const firstBatch = tables.map((t) => ({ name: t, type: 'collection', options: {}, info: { readOnly: false, uuid: '' } }));
+        return { ok: 1, cursor: { id: { $long: 0 }, ns: `${this._dbOf(doc)}.$cmd.listCollections`, firstBatch } };
+      }
+      case 'create': {
+        const engine = await this._ensureCollection(String(doc.create));
+        return { ok: 1, ns: engine ? `${this._dbOf(doc)}.${doc.create}` : '' };
+      }
+      case 'drop': {
+        try {
+          const engine = await this._getEngine();
+          engine.dropTable(String(doc.drop));
+          return { ok: 1, ns: `${this._dbOf(doc)}.${doc.drop}` };
+        } catch (e) {
+          return { ok: 1, ns: `${this._dbOf(doc)}.${doc.drop}` }; // Mongo 对不存在的 collection drop 也返回 ok
+        }
+      }
+      case 'insert': {
+        const coll = String(doc.insert);
+        const engine = await this._ensureCollection(coll);
+        const docs = doc.documents || [];
+        const ids = [];
+        for (const d of docs) {
+          const doc2 = { ...d };
+          ids.push(engine.insert(coll, doc2));
+        }
+        return { ok: 1, n: docs.length };
+      }
+      case 'find': {
+        const coll = String(doc.find);
+        const engine = await this._ensureCollection(coll);
+        const rows = engine.find(coll, doc.filter || {}, {
+          limit: typeof doc.limit === 'number' ? doc.limit : 0,
+          offset: typeof doc.skip === 'number' ? doc.skip : 0,
+        });
+        return { ok: 1, cursor: { id: { $long: 0 }, ns: `${this._dbOf(doc)}.${coll}`, firstBatch: rows } };
+      }
+      case 'getMore':
+        return { ok: 1, cursor: { id: { $long: 0 }, ns: String(doc.collection || ''), nextBatch: [] } };
+      case 'update': {
+        const coll = String(doc.update);
+        const engine = await this._ensureCollection(coll);
+        let n = 0;
+        const updates = doc.updates || [];
+        for (const u of updates) {
+          const q = u.q || {};
+          const set = u.u && u.u.$set ? u.u.$set : (u.u || {});
+          // 单文档更新
+          let target = engine.find(coll, q, { limit: 1 })[0] || null;
+          if (!target && u.upsert) {
+            const merged = { ...q, ...set };
+            engine.insert(coll, merged);
+            n++;
+            continue;
+          }
+          if (target) {
+            engine.update(coll, q, set);
+            n++;
+          }
+        }
+        return { ok: 1, n, nModified: n };
+      }
+      case 'delete': {
+        const coll = String(doc.delete);
+        const engine = await this._ensureCollection(coll);
+        let n = 0;
+        for (const d of (doc.deletes || [])) {
+          const res = engine.removeWhere(coll, d.q || {});
+          n += res.count;
+        }
+        return { ok: 1, n };
+      }
+      case 'count': {
+        const coll = String(doc.count);
+        const engine = await this._ensureCollection(coll);
+        const rows = engine.find(coll, doc.query || {});
+        return { ok: 1, n: Number(doc.limit) > 0 ? Math.min(rows.length, doc.limit) : rows.length };
+      }
+      case 'aggregate': {
+        const coll = String(doc.aggregate);
+        const engine = await this._ensureCollection(coll);
+        const pipeline = doc.pipeline || [];
+        let rows = engine.find(coll, {});
+        for (const stage of pipeline) {
+          if (stage.$match) rows = rows.filter((r) => this._match(r, stage.$match));
+          else if (stage.$count) rows = [{ [stage.$count]: rows.length }];
+          else if (stage.$limit) rows = rows.slice(0, stage.$limit);
+          else if (stage.$group) {
+            const acc = {};
+            for (const [k, v] of Object.entries(stage.$group)) {
+              if (v && v.$sum === 1 && k !== '_id') acc[k] = rows.length;
+            }
+            rows = [{ _id: 1, ...acc }];
+          }
+        }
+        return { ok: 1, cursor: { id: { $long: 0 }, ns: `${this._dbOf(doc)}.${coll}`, firstBatch: rows } };
+      }
+      default:
+        return { ok: 1, n: 0 };
+    }
+  }
+
+  _idOf(row) {
+    return row._id != null ? row._id : row.id;
+  }
+
+  _match(row, filter) {
+    for (const [k, cond] of Object.entries(filter || {})) {
+      if (k === '$or') {
+        if (!cond.some((f) => this._match(row, f))) return false;
+        continue;
+      }
+      if (cond && typeof cond === 'object' && !Array.isArray(cond)) {
+        for (const [op, v] of Object.entries(cond)) {
+          const rv = row[k];
+          if (op === '$gt' && !(rv > v)) return false;
+          if (op === '$gte' && !(rv >= v)) return false;
+          if (op === '$lt' && !(rv < v)) return false;
+          if (op === '$lte' && !(rv <= v)) return false;
+          if (op === '$ne' && !(rv !== v)) return false;
+          if (op === '$in' && !(v.includes(rv))) return false;
+          if (op === '$nin' && v.includes(rv)) return false;
+          if (op === '$exists' && (v ? (rv === undefined) : (rv !== undefined))) return false;
+        }
+      } else if (row[k] !== cond) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  get address() {
+    return this._server ? this._server.address() : null;
+  }
+
+  close(cb) {
+    for (const s of this._sockets) s.destroy();
+    const done = () => {
+      if (this._server) { this._server.close(cb || (() => {})); this._server = null; }
+      else if (cb) cb();
+    };
+    if (this._engine && typeof this._engine.stop === 'function') this._engine.stop().then(done).catch(done);
+    else done();
+    return this;
+  }
+}
+
+function createMongoServer(options) {
+  return new MongoServer(options || {});
+}
+
+module.exports = { MongoServer, createMongoServer, bsonDocument, bsonReadDocument };