@lakutata/orm 3.0.0-beta.6 → 3.1.0

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedValues.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedValues = void 0;
+/**
+ * lakutata: the bound of the integers of 64 bits BSON reads as numbers (its option promoteLongs): from -2^53 to 2^53.
+ */
+const PROMOTED_LONG = 2 ** 53;
+/**
+ * lakutata: the values of an embedded MongoDB: their copies as BSON stores them, the keys of the _id of the documents,
+ * and the serialization of the documents (their _id first, read without deserializing them).
+ */
+class EmbeddedValues {
+    constructor(bson, mingo) {
+        this.bson = bson;
+        this.mingo = mingo;
+    }
+    /**
+     * A copy of a value, as BSON stores it: the undefined fields dropped, the undefined items of the arrays null, the
+     * buffers Binary, the numbers of BSON (Int32, Double, Long, bigint) the ones BSON reads back, the values of BSON of
+     * another copy of bson (its ES module, when the driver has its CommonJS module) made with the one of the driver,
+     * which mingo compares.
+     *
+     * @param value
+     */
+    copy(value) {
+        if (value === undefined)
+            return null;
+        // The numbers of BSON as BSON reads them, numbers but the integers of 64 bits beyond 2^53 (the key of an _id
+        // is the same after a reopening)
+        if (typeof value === "bigint")
+            return value >= -BigInt(PROMOTED_LONG) &&
+                value <= BigInt(PROMOTED_LONG)
+                ? Number(value)
+                : this.bson.Long.fromBigInt(value);
+        if (value === null || typeof value !== "object")
+            return value;
+        if (Array.isArray(value))
+            return value.map((item) => this.copy(item));
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype === Object.prototype || prototype === null) {
+            const copied = {};
+            for (const key of Object.keys(value))
+                if (value[key] !== undefined)
+                    copied[key] = this.copy(value[key]);
+            return copied;
+        }
+        if (value instanceof Date)
+            return new Date(value.getTime());
+        if (value instanceof Uint8Array)
+            return new this.bson.Binary(Buffer.from(value));
+        if (value instanceof this.bson.Binary)
+            return new this.bson.Binary(Buffer.from(value.buffer), value.sub_type);
+        const type = value._bsontype;
+        if (type === "Int32" || type === "Double")
+            return value.valueOf();
+        if (type === "Long" &&
+            value.greaterThanOrEqual(-PROMOTED_LONG) &&
+            value.lessThanOrEqual(PROMOTED_LONG))
+            return value.toNumber();
+        if (typeof type === "string" &&
+            !(value instanceof (this.bson[type] ?? Object)))
+            return this.bson.EJSON.deserialize(this.bson.EJSON.serialize({ value: value }, { relaxed: false }), { relaxed: false }).value;
+        // ObjectId, Decimal128, Long... are not changed
+        return value;
+    }
+    /**
+     * The value at a path of a document.
+     *
+     * @param document
+     * @param path
+     */
+    valueAt(document, path) {
+        let value = document;
+        for (const name of path.split(".")) {
+            if (value === null || typeof value !== "object")
+                return undefined;
+            value = value[name];
+        }
+        return value;
+    }
+    /**
+     * The key of an _id: the bytes telling its value apart, as MongoDB does (1 and 1.0 are one key).
+     *
+     * @param id
+     */
+    idKey(id) {
+        if (id instanceof this.bson.ObjectId) {
+            const key = Buffer.allocUnsafe(13);
+            key[0] = 0x07;
+            key.set(id.id, 1);
+            return key;
+        }
+        if (typeof id === "string") {
+            const key = Buffer.allocUnsafe(1 + Buffer.byteLength(id));
+            key[0] = 0x02;
+            key.write(id, 1, "utf8");
+            return key;
+        }
+        if (typeof id === "number")
+            return this.numberKey(id);
+        // A Long beyond 2^53 that a number is exactly: the key of the number (MongoDB compares them by their values)
+        if (id?._bsontype === "Long") {
+            const number = id.toNumber();
+            if (Math.abs(number) < 2 ** 63 &&
+                this.bson.Long.fromNumber(number).equals(id))
+                return this.numberKey(number);
+        }
+        const text = Buffer.from(this.bson.EJSON.stringify(id, { relaxed: false }));
+        const key = Buffer.allocUnsafe(1 + text.length);
+        key[0] = 0xff;
+        text.copy(key, 1);
+        return key;
+    }
+    /**
+     * The key of the _id of a serialized document, read from its first element when it is its _id (the documents
+     * are serialized so), else from the document deserialized.
+     *
+     * @param data
+     * @param start the start of the document in the data
+     */
+    idKeyOf(data, start = 0) {
+        // The first element: its type, then its name "_id\0"
+        if (data[start + 5] === 0x5f &&
+            data[start + 6] === 0x69 &&
+            data[start + 7] === 0x64 &&
+            data[start + 8] === 0) {
+            const value = start + 9;
+            switch (data[start + 4]) {
+                case 0x07: {
+                    const key = Buffer.allocUnsafe(13);
+                    key[0] = 0x07;
+                    data.copy(key, 1, value, value + 12);
+                    return key;
+                }
+                case 0x02: {
+                    const length = data.readInt32LE(value) - 1;
+                    const key = Buffer.allocUnsafe(1 + length);
+                    key[0] = 0x02;
+                    data.copy(key, 1, value + 4, value + 4 + length);
+                    return key;
+                }
+                case 0x01:
+                    return this.numberKey(data.readDoubleLE(value));
+                case 0x10:
+                    return this.numberKey(data.readInt32LE(value));
+            }
+        }
+        const size = data.readInt32LE(start);
+        return this.idKey(this.bson.BSON.deserialize(data.subarray(start, start + size))._id);
+    }
+    /**
+     * Serializes a document, its _id first.
+     *
+     * @param document
+     */
+    serialize(document) {
+        const { _id, ...fields } = document;
+        return this.bson.BSON.serialize(_id === undefined ? fields : { _id: _id, ...fields });
+    }
+    /**
+     * Deserializes a document.
+     *
+     * @param data
+     */
+    deserialize(data) {
+        return this.bson.BSON.deserialize(data);
+    }
+    numberKey(value) {
+        const key = Buffer.allocUnsafe(9);
+        key[0] = 0x01;
+        key.writeDoubleBE(value === 0 ? 0 : value, 1);
+        return key;
+    }
+}
+exports.EmbeddedValues = EmbeddedValues;
+//# sourceMappingURL=EmbeddedValues.js.map

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedValues.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedValues.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * lakutata: a document of an embedded collection.\n */\nexport type EmbeddedDocument = { [key: string]: any }\n\n/**\n * lakutata: the bound of the integers of 64 bits BSON reads as numbers (its option promoteLongs): from -2^53 to 2^53.\n */\nconst PROMOTED_LONG = 2 ** 53\n\n/**\n * lakutata: the values of an embedded MongoDB: their copies as BSON stores them, the keys of the _id of the documents,\n * and the serialization of the documents (their _id first, read without deserializing them).\n */\nexport class EmbeddedValues {\n    constructor(\n        readonly bson: any,\n        readonly mingo: any,\n    ) {}\n\n    /**\n     * A copy of a value, as BSON stores it: the undefined fields dropped, the undefined items of the arrays null, the\n     * buffers Binary, the numbers of BSON (Int32, Double, Long, bigint) the ones BSON reads back, the values of BSON of\n     * another copy of bson (its ES module, when the driver has its CommonJS module) made with the one of the driver,\n     * which mingo compares.\n     *\n     * @param value\n     */\n    copy(value: any): any {\n        if (value === undefined) return null\n        // The numbers of BSON as BSON reads them, numbers but the integers of 64 bits beyond 2^53 (the key of an _id\n        // is the same after a reopening)\n        if (typeof value === \"bigint\")\n            return value >= -BigInt(PROMOTED_LONG) &&\n                value <= BigInt(PROMOTED_LONG)\n                ? Number(value)\n                : this.bson.Long.fromBigInt(value)\n        if (value === null || typeof value !== \"object\") return value\n        if (Array.isArray(value)) return value.map((item) => this.copy(item))\n        const prototype = Object.getPrototypeOf(value)\n        if (prototype === Object.prototype || prototype === null) {\n            const copied: EmbeddedDocument = {}\n            for (const key of Object.keys(value))\n                if (value[key] !== undefined) copied[key] = this.copy(value[key])\n            return copied\n        }\n        if (value instanceof Date) return new Date(value.getTime())\n        if (value instanceof Uint8Array)\n            return new this.bson.Binary(Buffer.from(value))\n        if (value instanceof this.bson.Binary)\n            return new this.bson.Binary(\n                Buffer.from(value.buffer),\n                value.sub_type,\n            )\n        const type = value._bsontype\n        if (type === \"Int32\" || type === \"Double\") return value.valueOf()\n        if (\n            type === \"Long\" &&\n            value.greaterThanOrEqual(-PROMOTED_LONG) &&\n            value.lessThanOrEqual(PROMOTED_LONG)\n        )\n            return value.toNumber()\n        if (\n            typeof type === \"string\" &&\n            !(value instanceof (this.bson[type] ?? Object))\n        )\n            return this.bson.EJSON.deserialize(\n                this.bson.EJSON.serialize({ value: value }, { relaxed: false }),\n                { relaxed: false },\n            ).value\n        // ObjectId, Decimal128, Long... are not changed\n        return value\n    }\n\n    /**\n     * The value at a path of a document.\n     *\n     * @param document\n     * @param path\n     */\n    valueAt(document: EmbeddedDocument, path: string): any {\n        let value: any = document\n        for (const name of path.split(\".\")) {\n            if (value === null || typeof value !== \"object\") return undefined\n            value = value[name]\n        }\n        return value\n    }\n\n    /**\n     * The key of an _id: the bytes telling its value apart, as MongoDB does (1 and 1.0 are one key).\n     *\n     * @param id\n     */\n    idKey(id: any): Buffer {\n        if (id instanceof this.bson.ObjectId) {\n            const key = Buffer.allocUnsafe(13)\n            key[0] = 0x07\n            key.set(id.id, 1)\n            return key\n        }\n        if (typeof id === \"string\") {\n            const key = Buffer.allocUnsafe(1 + Buffer.byteLength(id))\n            key[0] = 0x02\n            key.write(id, 1, \"utf8\")\n            return key\n        }\n        if (typeof id === \"number\") return this.numberKey(id)\n        // A Long beyond 2^53 that a number is exactly: the key of the number (MongoDB compares them by their values)\n        if (id?._bsontype === \"Long\") {\n            const number = id.toNumber()\n            if (\n                Math.abs(number) < 2 ** 63 &&\n                this.bson.Long.fromNumber(number).equals(id)\n            )\n                return this.numberKey(number)\n        }\n        const text = Buffer.from(\n            this.bson.EJSON.stringify(id, { relaxed: false }),\n        )\n        const key = Buffer.allocUnsafe(1 + text.length)\n        key[0] = 0xff\n        text.copy(key, 1)\n        return key\n    }\n\n    /**\n     * The key of the _id of a serialized document, read from its first element when it is its _id (the documents\n     * are serialized so), else from the document deserialized.\n     *\n     * @param data\n     * @param start the start of the document in the data\n     */\n    idKeyOf(data: Buffer, start = 0): Buffer {\n        // The first element: its type, then its name \"_id\\0\"\n        if (\n            data[start + 5] === 0x5f &&\n            data[start + 6] === 0x69 &&\n            data[start + 7] === 0x64 &&\n            data[start + 8] === 0\n        ) {\n            const value = start + 9\n            switch (data[start + 4]) {\n                case 0x07: {\n                    const key = Buffer.allocUnsafe(13)\n                    key[0] = 0x07\n                    data.copy(key, 1, value, value + 12)\n                    return key\n                }\n                case 0x02: {\n                    const length = data.readInt32LE(value) - 1\n                    const key = Buffer.allocUnsafe(1 + length)\n                    key[0] = 0x02\n                    data.copy(key, 1, value + 4, value + 4 + length)\n                    return key\n                }\n                case 0x01:\n                    return this.numberKey(data.readDoubleLE(value))\n                case 0x10:\n                    return this.numberKey(data.readInt32LE(value))\n            }\n        }\n        const size = data.readInt32LE(start)\n        return this.idKey(\n            this.bson.BSON.deserialize(data.subarray(start, start + size))._id,\n        )\n    }\n\n    /**\n     * Serializes a document, its _id first.\n     *\n     * @param document\n     */\n    serialize(document: EmbeddedDocument): Buffer {\n        const { _id, ...fields } = document\n        return this.bson.BSON.serialize(\n            _id === undefined ? fields : { _id: _id, ...fields },\n        )\n    }\n\n    /**\n     * Deserializes a document.\n     *\n     * @param data\n     */\n    deserialize(data: Uint8Array): EmbeddedDocument {\n        return this.bson.BSON.deserialize(data)\n    }\n\n    protected numberKey(value: number): Buffer {\n        const key = Buffer.allocUnsafe(9)\n        key[0] = 0x01\n        key.writeDoubleBE(value === 0 ? 0 : value, 1)\n        return key\n    }\n}\n"]}

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedWorker.d.ts

@@ -0,0 +1,12 @@
+import type { MessagePort } from "worker_threads";
+import type { EmbeddedWorkerData } from "./EmbeddedWorkerProtocol";
+/**
+ * lakutata: the worker thread of an embedded MongoDB (the option worker): it opens the database, replies to its
+ * opening (the id 0), then to the calls of the client of the main thread (EmbeddedWorkerClient), their arguments and
+ * their results in BSON. Its code is bundled with mingo and bson (EmbeddedWorkerCode), from which the main thread
+ * starts it.
+ *
+ * @param port
+ * @param data
+ */
+export declare function startEmbeddedWorker(port: MessagePort, data: EmbeddedWorkerData): Promise<void>;

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedWorker.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startEmbeddedWorker = startEmbeddedWorker;
+const tslib_1 = require("tslib");
+const bson = tslib_1.__importStar(require("bson"));
+const mingo = tslib_1.__importStar(require("mingo"));
+const worker_threads_1 = require("worker_threads");
+const TypeORMError_1 = require("../../error/TypeORMError");
+const EmbeddedClient_1 = require("./EmbeddedClient");
+const EmbeddedCollectionStore_1 = require("./EmbeddedCollectionStore");
+const EmbeddedWorkerProtocol_1 = require("./EmbeddedWorkerProtocol");
+/**
+ * lakutata: yields the event loop.
+ */
+function yieldLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+/**
+ * lakutata: the documents of a find or an aggregation in batches of BSON, the event loop yielded between them.
+ *
+ * @param documents
+ */
+async function batchesOf(documents) {
+    const batches = [];
+    for (let start = 0; start < documents.length; start += EmbeddedWorkerProtocol_1.REPLY_BATCH) {
+        if (start)
+            await yieldLoop();
+        batches.push((0, EmbeddedWorkerProtocol_1.encodeDocuments)(bson, documents.slice(start, start + EmbeddedWorkerProtocol_1.REPLY_BATCH)));
+    }
+    return batches;
+}
+const cursors = new Map();
+let nextCursor = 1;
+/**
+ * lakutata: closes a cursor of the worker thread.
+ *
+ * @param id
+ */
+function kill(id) {
+    const cursor = cursors.get(id);
+    if (!cursor)
+        return;
+    cursors.delete(id);
+    clearTimeout(cursor.timer);
+    void cursor.batches.return?.()?.catch(() => { });
+}
+/**
+ * lakutata: the next batch of a cursor of the worker thread, the cursor closed at its end.
+ *
+ * @param id
+ * @param request
+ */
+async function more(id, request) {
+    const cursor = cursors.get(id);
+    if (!cursor)
+        throw new TypeORMError_1.TypeORMError(`The cursor of mongo-embedded is closed: it was not read for ${EmbeddedCollectionStore_1.SCAN_TIMEOUT / 60000} minutes`);
+    clearTimeout(cursor.timer);
+    let result;
+    try {
+        result = await cursor.batches.next();
+    }
+    catch (error) {
+        kill(id);
+        throw error;
+    }
+    if (result.done) {
+        kill(id);
+        return { id: request.id, cursor: id, done: true, batches: [] };
+    }
+    cursor.timer = setTimeout(() => kill(id), EmbeddedCollectionStore_1.SCAN_TIMEOUT);
+    cursor.timer.unref?.();
+    return {
+        id: request.id,
+        cursor: id,
+        done: false,
+        batches: [(0, EmbeddedWorkerProtocol_1.encodeDocuments)(bson, result.value)],
+    };
+}
+/**
+ * lakutata: the reply of the worker thread to a call of the main thread.
+ *
+ * @param client
+ * @param request
+ */
+async function handle(client, request) {
+    const call = request.payload
+        ? bson.deserialize(request.payload)
+        : {};
+    switch (request.op) {
+        case "collection": {
+            if (!EmbeddedWorkerProtocol_1.COLLECTION_METHODS.has(call.method))
+                throw new TypeORMError_1.TypeORMError(`${call.method} is not a method of the collections of mongo-embedded`);
+            const collection = client.db().collection(call.collection);
+            const args = request.documents
+                ? [(0, EmbeddedWorkerProtocol_1.decodeDocuments)(bson, request.documents), ...call.args]
+                : call.args;
+            const result = await collection[call.method](...args);
+            return { id: request.id, payload: (0, EmbeddedWorkerProtocol_1.encode)(bson, { result: result }) };
+        }
+        case "db": {
+            if (!EmbeddedWorkerProtocol_1.DB_METHODS.has(call.method))
+                throw new TypeORMError_1.TypeORMError(`${call.method} is not a method of the databases of mongo-embedded`);
+            const db = client.db();
+            const result = await db[call.method](...call.args);
+            return { id: request.id, payload: (0, EmbeddedWorkerProtocol_1.encode)(bson, { result: result }) };
+        }
+        case "find":
+        case "open": {
+            const cursor = client
+                .db()
+                .collection(call.collection)
+                .find(call.query ?? {});
+            if (call.projection)
+                cursor.project(call.projection);
+            if (call.sort)
+                cursor.sort(call.sort);
+            if (call.skip !== undefined)
+                cursor.skip(call.skip);
+            if (call.limit !== undefined)
+                cursor.limit(call.limit);
+            const batches = request.op === "open" && cursor.streamedBatches();
+            if (!batches)
+                return {
+                    id: request.id,
+                    batches: await batchesOf(await cursor.toArray()),
+                };
+            const id = nextCursor++;
+            cursors.set(id, { batches: batches });
+            return more(id, request);
+        }
+        case "more":
+            return more(call.cursor, request);
+        case "kill":
+            kill(call.cursor);
+            return { id: request.id };
+        case "aggregate":
+            return {
+                id: request.id,
+                batches: await batchesOf(await client
+                    .db()
+                    .collection(call.collection)
+                    .aggregate(call.pipeline, call.options ?? undefined)
+                    .toArray()),
+            };
+        case "close":
+            await client.close();
+            return { id: request.id };
+    }
+}
+/**
+ * lakutata: the worker thread of an embedded MongoDB (the option worker): it opens the database, replies to its
+ * opening (the id 0), then to the calls of the client of the main thread (EmbeddedWorkerClient), their arguments and
+ * their results in BSON. Its code is bundled with mingo and bson (EmbeddedWorkerCode), from which the main thread
+ * starts it.
+ *
+ * @param port
+ * @param data
+ */
+async function startEmbeddedWorker(port, data) {
+    let client;
+    try {
+        client = await EmbeddedClient_1.EmbeddedClient.connect(data.directory, data.options, mingo, bson, data.token);
+    }
+    catch (error) {
+        port.postMessage({ id: 0, error: (0, EmbeddedWorkerProtocol_1.describeError)(bson, error) });
+        return;
+    }
+    // The calls are handled as they come, not queued: as on the main thread (worker false), a call awaiting (a write
+    // between its batches, a find) lets the next ones run, a close included; the replies are posted as the calls end,
+    // in any order, the client matching them by their id
+    port.on("message", (request) => {
+        handle(client, request).then((reply) => port.postMessage(reply), (error) => port.postMessage({
+            id: request.id,
+            error: (0, EmbeddedWorkerProtocol_1.describeError)(bson, error),
+        }));
+    });
+    port.postMessage({ id: 0 });
+}
+if (worker_threads_1.parentPort && worker_threads_1.workerData?.[EmbeddedWorkerProtocol_1.WORKER_DATA_KEY])
+    void startEmbeddedWorker(worker_threads_1.parentPort, worker_threads_1.workerData[EmbeddedWorkerProtocol_1.WORKER_DATA_KEY]);
+//# sourceMappingURL=EmbeddedWorker.js.map

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedWorker.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedWorker.ts"],"names":[],"mappings":"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","sourcesContent":["import * as bson from \"bson\"\nimport * as mingo from \"mingo\"\nimport type { MessagePort } from \"worker_threads\"\nimport { parentPort, workerData } from \"worker_threads\"\nimport { TypeORMError } from \"../../error/TypeORMError\"\nimport { EmbeddedClient } from \"./EmbeddedClient\"\nimport { SCAN_TIMEOUT } from \"./EmbeddedCollectionStore\"\nimport type { EmbeddedDocument } from \"./EmbeddedValues\"\nimport type {\n    EmbeddedReply,\n    EmbeddedRequest,\n    EmbeddedWorkerData,\n} from \"./EmbeddedWorkerProtocol\"\nimport {\n    COLLECTION_METHODS,\n    DB_METHODS,\n    decodeDocuments,\n    describeError,\n    encode,\n    encodeDocuments,\n    REPLY_BATCH,\n    WORKER_DATA_KEY,\n} from \"./EmbeddedWorkerProtocol\"\n\n/**\n * lakutata: yields the event loop.\n */\nfunction yieldLoop(): Promise<void> {\n    return new Promise((resolve) => setImmediate(resolve))\n}\n\n/**\n * lakutata: the documents of a find or an aggregation in batches of BSON, the event loop yielded between them.\n *\n * @param documents\n */\nasync function batchesOf(documents: EmbeddedDocument[]): Promise<Uint8Array[]> {\n    const batches: Uint8Array[] = []\n    for (let start = 0; start < documents.length; start += REPLY_BATCH) {\n        if (start) await yieldLoop()\n        batches.push(\n            encodeDocuments(bson, documents.slice(start, start + REPLY_BATCH)),\n        )\n    }\n    return batches\n}\n\n/**\n * lakutata: a cursor of the worker thread read a batch at a time, closed when it is not read for SCAN_TIMEOUT (as\n * MongoDB closes them).\n */\ninterface Cursor {\n    batches: AsyncIterator<EmbeddedDocument[]>\n    timer?: ReturnType<typeof setTimeout>\n}\n\nconst cursors = new Map<number, Cursor>()\n\nlet nextCursor = 1\n\n/**\n * lakutata: closes a cursor of the worker thread.\n *\n * @param id\n */\nfunction kill(id: number): void {\n    const cursor = cursors.get(id)\n    if (!cursor) return\n    cursors.delete(id)\n    clearTimeout(cursor.timer)\n    void cursor.batches.return?.()?.catch(() => {})\n}\n\n/**\n * lakutata: the next batch of a cursor of the worker thread, the cursor closed at its end.\n *\n * @param id\n * @param request\n */\nasync function more(id: number, request: EmbeddedRequest): Promise<EmbeddedReply> {\n    const cursor = cursors.get(id)\n    if (!cursor)\n        throw new TypeORMError(\n            `The cursor of mongo-embedded is closed: it was not read for ${SCAN_TIMEOUT / 60000} minutes`,\n        )\n    clearTimeout(cursor.timer)\n    let result: IteratorResult<EmbeddedDocument[]>\n    try {\n        result = await cursor.batches.next()\n    } catch (error) {\n        kill(id)\n        throw error\n    }\n    if (result.done) {\n        kill(id)\n        return { id: request.id, cursor: id, done: true, batches: [] }\n    }\n    cursor.timer = setTimeout(() => kill(id), SCAN_TIMEOUT)\n    cursor.timer.unref?.()\n    return {\n        id: request.id,\n        cursor: id,\n        done: false,\n        batches: [encodeDocuments(bson, result.value)],\n    }\n}\n\n/**\n * lakutata: the reply of the worker thread to a call of the main thread.\n *\n * @param client\n * @param request\n */\nasync function handle(\n    client: EmbeddedClient,\n    request: EmbeddedRequest,\n): Promise<EmbeddedReply> {\n    const call: EmbeddedDocument = request.payload\n        ? bson.deserialize(request.payload)\n        : {}\n    switch (request.op) {\n        case \"collection\": {\n            if (!COLLECTION_METHODS.has(call.method))\n                throw new TypeORMError(\n                    `${call.method} is not a method of the collections of mongo-embedded`,\n                )\n            const collection: any = client.db().collection(call.collection)\n            const args = request.documents\n                ? [decodeDocuments(bson, request.documents), ...call.args]\n                : call.args\n            const result = await collection[call.method](...args)\n            return { id: request.id, payload: encode(bson, { result: result }) }\n        }\n        case \"db\": {\n            if (!DB_METHODS.has(call.method))\n                throw new TypeORMError(\n                    `${call.method} is not a method of the databases of mongo-embedded`,\n                )\n            const db: any = client.db()\n            const result = await db[call.method](...call.args)\n            return { id: request.id, payload: encode(bson, { result: result }) }\n        }\n        case \"find\":\n        case \"open\": {\n            const cursor = client\n                .db()\n                .collection(call.collection)\n                .find(call.query ?? {})\n            if (call.projection) cursor.project(call.projection)\n            if (call.sort) cursor.sort(call.sort)\n            if (call.skip !== undefined) cursor.skip(call.skip)\n            if (call.limit !== undefined) cursor.limit(call.limit)\n            const batches = request.op === \"open\" && cursor.streamedBatches()\n            if (!batches)\n                return {\n                    id: request.id,\n                    batches: await batchesOf(await cursor.toArray()),\n                }\n            const id = nextCursor++\n            cursors.set(id, { batches: batches })\n            return more(id, request)\n        }\n        case \"more\":\n            return more(call.cursor, request)\n        case \"kill\":\n            kill(call.cursor)\n            return { id: request.id }\n        case \"aggregate\":\n            return {\n                id: request.id,\n                batches: await batchesOf(\n                    await client\n                        .db()\n                        .collection(call.collection)\n                        .aggregate(call.pipeline, call.options ?? undefined)\n                        .toArray(),\n                ),\n            }\n        case \"close\":\n            await client.close()\n            return { id: request.id }\n    }\n}\n\n/**\n * lakutata: the worker thread of an embedded MongoDB (the option worker): it opens the database, replies to its\n * opening (the id 0), then to the calls of the client of the main thread (EmbeddedWorkerClient), their arguments and\n * their results in BSON. Its code is bundled with mingo and bson (EmbeddedWorkerCode), from which the main thread\n * starts it.\n *\n * @param port\n * @param data\n */\nexport async function startEmbeddedWorker(\n    port: MessagePort,\n    data: EmbeddedWorkerData,\n): Promise<void> {\n    let client: EmbeddedClient\n    try {\n        client = await EmbeddedClient.connect(\n            data.directory,\n            data.options,\n            mingo,\n            bson,\n            data.token,\n        )\n    } catch (error) {\n        port.postMessage({ id: 0, error: describeError(bson, error) })\n        return\n    }\n    // The calls are handled as they come, not queued: as on the main thread (worker false), a call awaiting (a write\n    // between its batches, a find) lets the next ones run, a close included; the replies are posted as the calls end,\n    // in any order, the client matching them by their id\n    port.on(\"message\", (request: EmbeddedRequest) => {\n        handle(client, request).then(\n            (reply) => port.postMessage(reply),\n            (error) =>\n                port.postMessage({\n                    id: request.id,\n                    error: describeError(bson, error),\n                }),\n        )\n    })\n    port.postMessage({ id: 0 })\n}\n\nif (parentPort && workerData?.[WORKER_DATA_KEY])\n    void startEmbeddedWorker(parentPort, workerData[WORKER_DATA_KEY])\n"]}

package/dist/vendor/typeorm/driver/mongo-embedded/EmbeddedWorkerClient.d.ts

@@ -0,0 +1,204 @@
+import type { ResourceLimits } from "worker_threads";
+import { Worker } from "worker_threads";
+import { TypeORMError } from "../../error/TypeORMError";
+import { EmbeddedArrayCursor, EmbeddedResults } from "./EmbeddedClient";
+import type { EmbeddedStoreOptions } from "./EmbeddedStore";
+import type { EmbeddedDocument } from "./EmbeddedValues";
+import type { EmbeddedReply, EmbeddedRequest } from "./EmbeddedWorkerProtocol";
+/**
+ * lakutata: the cursor of a find of a collection of the worker thread: its filter, projection, order, skip and limit
+ * sent with the call reading it.
+ */
+export declare class EmbeddedWorkerFindCursor extends EmbeddedResults {
+    protected readonly collection: EmbeddedWorkerCollection;
+    protected query: EmbeddedDocument;
+    protected projection?: EmbeddedDocument;
+    protected order?: EmbeddedDocument;
+    protected skipped?: number;
+    protected limited?: number;
+    constructor(collection: EmbeddedWorkerCollection, query: EmbeddedDocument);
+    filter(query: EmbeddedDocument): this;
+    project(projection: EmbeddedDocument): this;
+    sort(order: EmbeddedDocument): this;
+    skip(count: number): this;
+    limit(count: number): this;
+    protected documents(): Promise<EmbeddedDocument[]>;
+    protected batches(): AsyncIterator<EmbeddedDocument[]> | undefined;
+    protected call(): EmbeddedDocument;
+}
+/**
+ * lakutata: a collection of the worker thread, with the methods of the collections of MongoDB that TypeORM calls:
+ * each of them a call of the worker thread.
+ */
+export declare class EmbeddedWorkerCollection {
+    readonly collectionName: string;
+    readonly client: EmbeddedWorkerClient;
+    constructor(collectionName: string, client: EmbeddedWorkerClient);
+    find(query?: EmbeddedDocument, options?: EmbeddedDocument): EmbeddedWorkerFindCursor;
+    findOne(query?: EmbeddedDocument, options?: EmbeddedDocument): Promise<any>;
+    aggregate(pipeline: EmbeddedDocument[], options?: EmbeddedDocument): EmbeddedArrayCursor;
+    listIndexes(): EmbeddedArrayCursor;
+    /**
+     * Inserts a document, its _id added when missing (to the document given, as MongoDB does).
+     *
+     * @param document
+     */
+    insertOne(document: EmbeddedDocument): Promise<any>;
+    /**
+     * Inserts documents, their _id added when missing (to the documents given, as MongoDB does).
+     *
+     * @param documents
+     */
+    insertMany(documents: EmbeddedDocument[], options?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        insertedCount: number;
+        insertedIds: {
+            [index: number]: any;
+        };
+    }>;
+    countDocuments(...args: any[]): Promise<any>;
+    count(...args: any[]): Promise<any>;
+    estimatedDocumentCount(...args: any[]): Promise<any>;
+    distinct(...args: any[]): Promise<any>;
+    updateOne(...args: any[]): Promise<any>;
+    updateMany(...args: any[]): Promise<any>;
+    replaceOne(...args: any[]): Promise<any>;
+    deleteOne(...args: any[]): Promise<any>;
+    deleteMany(...args: any[]): Promise<any>;
+    createIndex(...args: any[]): Promise<any>;
+    createIndexes(...args: any[]): Promise<any>;
+    indexes(...args: any[]): Promise<any>;
+    indexExists(...args: any[]): Promise<any>;
+    indexInformation(...args: any[]): Promise<any>;
+    dropIndex(...args: any[]): Promise<any>;
+    dropIndexes(...args: any[]): Promise<any>;
+    isCapped(...args: any[]): Promise<any>;
+    bulkWrite(...args: any[]): Promise<any>;
+    findOneAndDelete(...args: any[]): Promise<any>;
+    findOneAndReplace(...args: any[]): Promise<any>;
+    findOneAndUpdate(...args: any[]): Promise<any>;
+    rename(...args: any[]): Promise<any>;
+    initializeOrderedBulkOp(): never;
+    initializeUnorderedBulkOp(): never;
+    watch(): never;
+    /**
+     * Calls a method of the collection in the worker thread.
+     *
+     * @param method
+     * @param args
+     */
+    protected call(method: string, args: any[]): Promise<any>;
+}
+/**
+ * lakutata: the database of the worker thread.
+ */
+export declare class EmbeddedWorkerDb {
+    readonly databaseName: string;
+    protected readonly client: EmbeddedWorkerClient;
+    protected readonly collections: Map<string, EmbeddedWorkerCollection>;
+    constructor(databaseName: string, client: EmbeddedWorkerClient);
+    collection(name: string): EmbeddedWorkerCollection;
+    dropDatabase(): Promise<boolean>;
+    dropCollection(name: string): Promise<boolean>;
+}
+/**
+ * lakutata: the client of an embedded MongoDB run in a worker thread (the option worker), with the API of the client
+ * of MongoDB that TypeORM calls: its calls and their results sent in BSON (the documents of a find decoded in
+ * batches, the event loop yielded between them). The worker thread does not keep the process running while no call
+ * waits for it. When it exits (its heap out of memory...), the calls waiting fail, and the directory it locked is
+ * unlocked.
+ */
+export declare class EmbeddedWorkerClient {
+    protected readonly worker: Worker;
+    readonly bson: any;
+    readonly directory: string | undefined;
+    protected readonly token: string;
+    /**
+     * The calls waiting for their reply, by their ids.
+     */
+    protected readonly calls: Map<number, (reply: EmbeddedReply) => void>;
+    protected nextId: number;
+    /**
+     * Why the calls fail: the worker thread exited, or the database is closed.
+     */
+    protected failure?: TypeORMError;
+    protected database?: EmbeddedWorkerDb;
+    /**
+     * Its closing (the calls of close() share it).
+     */
+    protected closing?: Promise<void>;
+    /**
+     * @param worker
+     * @param bson
+     * @param directory
+     * @param token the token of the connection in the file LOCK of the directory
+     */
+    protected constructor(worker: Worker, bson: any, directory: string | undefined, token: string);
+    /**
+     * Opens a database in a worker thread: resolved once the worker thread opened it (its directory locked, the files
+     * of its collections read).
+     *
+     * @param directory the directory of the database, or ":memory:"
+     * @param options
+     * @param bson
+     * @param resourceLimits the limits of the worker thread, if any (the ones of this thread otherwise)
+     */
+    static connect(directory: string | undefined, options: EmbeddedStoreOptions, bson: any, resourceLimits?: ResourceLimits): Promise<EmbeddedWorkerClient>;
+    db(name?: string): EmbeddedWorkerDb;
+    /**
+     * Calls the worker thread: its result.
+     *
+     * @param op
+     * @param call the arguments of the call
+     * @param documents the documents of an insertMany (encodeDocuments)
+     */
+    call(op: EmbeddedRequest["op"], call: EmbeddedDocument, documents?: Uint8Array): Promise<any>;
+    /**
+     * The documents of a find or an aggregation of the worker thread, decoded a batch at a time, the event loop yielded
+     * between them.
+     *
+     * @param op
+     * @param call the arguments of the call
+     */
+    documents(op: "find" | "aggregate", call: EmbeddedDocument): Promise<EmbeddedDocument[]>;
+    /**
+     * The documents of a find read a batch at a time: a cursor of the worker thread, read as they are asked (closed
+     * at its end, or when the stream is closed before it).
+     *
+     * @param call the arguments of the find
+     */
+    streamed(call: EmbeddedDocument): AsyncGenerator<EmbeddedDocument[]>;
+    /**
+     * Closes the database (its files written to the disk, its snapshots), then the worker thread: the calls still
+     * waiting then fail.
+     */
+    close(): Promise<void>;
+    /**
+     * Closes the database, then ends the worker thread. Closed after the worker thread exited, it resolves (the
+     * database is closed). The calls fail before the thread is ended: its exit is not taken for a failure (exited),
+     * the database unlocked its directory.
+     */
+    protected closeWorker(): Promise<void>;
+    /**
+     * Sends a call to the worker thread: its reply (the failure of the worker thread replies to the calls waiting).
+     *
+     * @param op
+     * @param payload
+     * @param documents the documents of an insertMany (encodeDocuments)
+     */
+    protected request(op: EmbeddedRequest["op"], payload?: Uint8Array, documents?: Uint8Array): Promise<EmbeddedReply>;
+    protected replied(reply: EmbeddedReply): void;
+    /**
+     * Fails the calls waiting, and the calls made after them.
+     *
+     * @param failure
+     */
+    protected fail(failure: TypeORMError): void;
+    /**
+     * After the worker thread exited, not closed: the calls waiting fail, and the directory it locked (its file LOCK
+     * holding the token of the connection) is unlocked.
+     *
+     * @param failure
+     */
+    protected exited(failure: TypeORMError): void;
+}