@lakutata/orm 3.0.0 → 3.1.1

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

@@ -0,0 +1,117 @@
+import type { EmbeddedStoreOptions } from "./EmbeddedStore";
+import type { EmbeddedDocument } from "./EmbeddedValues";
+/**
+ * lakutata: the key of the data of the worker thread of an embedded MongoDB in its workerData.
+ */
+export declare const WORKER_DATA_KEY = "lakutataMongoEmbedded";
+/**
+ * lakutata: the data of the worker thread of an embedded MongoDB: the directory of its database (none in memory), the
+ * options of its store, and the token of the connection in the file LOCK of the directory (the client removes the
+ * LOCK of its connection when the worker thread exits).
+ */
+export interface EmbeddedWorkerData {
+    directory?: string;
+    options: EmbeddedStoreOptions;
+    token: string;
+}
+/**
+ * lakutata: a call of the worker thread of an embedded MongoDB: its operation, and its arguments in BSON.
+ *  - "collection": a method of a collection ({ collection, method, args })
+ *  - "db": a method of the database ({ method, args })
+ *  - "find": the documents of a find ({ collection, query, projection, sort, skip, limit })
+ *  - "aggregate": the documents of an aggregation ({ collection, pipeline, options })
+ *  - "open": a cursor of a find read a batch at a time, and its first batch (as "find"); a find not streamed
+ *    (isStreamed) replies all its batches, without a cursor
+ *  - "more": the next batch of a cursor ({ cursor })
+ *  - "kill": the closing of a cursor ({ cursor })
+ *  - "close": the closing of the database
+ */
+export interface EmbeddedRequest {
+    id: number;
+    /**
+     * The documents of an insertMany (its first argument), each one in BSON (encodeDocuments).
+     */
+    documents?: Uint8Array;
+    op: "collection" | "db" | "find" | "aggregate" | "open" | "more" | "kill" | "close";
+    payload?: Uint8Array;
+}
+/**
+ * lakutata: the reply of the worker thread to a call (the id 0 is the one of its opening): its result in BSON
+ * ({ result }), the documents of a find or an aggregation in batches (encodeDocuments), the id of a cursor and
+ * whether it is read to its end, or its error.
+ */
+export interface EmbeddedReply {
+    id: number;
+    payload?: Uint8Array;
+    batches?: Uint8Array[];
+    cursor?: number;
+    done?: boolean;
+    error?: EmbeddedWorkerError;
+}
+/**
+ * lakutata: an error of the worker thread, sent to the main thread: its name, its message, and its fields (the code
+ * of a duplicate key...) in BSON.
+ */
+export interface EmbeddedWorkerError {
+    name: string;
+    message: string;
+    fields?: Uint8Array;
+}
+/**
+ * lakutata: the documents of a batch of the documents of a find or an aggregation.
+ */
+export declare const REPLY_BATCH = 1000;
+/**
+ * lakutata: the methods of the collections the main thread calls with the operation "collection" (the finds and
+ * the aggregations are the operations "find" and "aggregate").
+ */
+export declare const COLLECTION_METHODS: Set<string>;
+/**
+ * lakutata: the methods of the database the main thread calls with the operation "db".
+ */
+export declare const DB_METHODS: Set<string>;
+/**
+ * lakutata: the options of the serialization of the calls and their results: the undefined fields dropped (as the
+ * copies of the values of the store drop them; the undefined items of the arrays are null).
+ */
+export declare const SERIALIZE_OPTIONS: {
+    ignoreUndefined: boolean;
+};
+/**
+ * lakutata: a value in BSON. One larger than the internal buffer of bson (17 MiB) is serialized with a buffer of its
+ * size (bson keeps it then): the documents are encoded one at a time (encodeDocuments), each of them smaller.
+ *
+ * @param bson
+ * @param value
+ */
+export declare function encode(bson: any, value: EmbeddedDocument): Uint8Array;
+/**
+ * lakutata: documents in BSON, one after the other.
+ *
+ * @param bson
+ * @param documents
+ */
+export declare function encodeDocuments(bson: any, documents: EmbeddedDocument[]): Uint8Array;
+/**
+ * lakutata: the documents of encodeDocuments.
+ *
+ * @param bson
+ * @param bytes
+ */
+export declare function decodeDocuments(bson: any, bytes: Uint8Array): EmbeddedDocument[];
+/**
+ * lakutata: an error of the worker thread, to send to the main thread.
+ *
+ * @param bson
+ * @param error
+ */
+export declare function describeError(bson: any, error: any): EmbeddedWorkerError;
+/**
+ * lakutata: an error of the worker thread, made again in the main thread: a TypeORMError of its name, its message
+ * and its fields. Made by the async function awaiting the reply, its stack is the one of the call (the async stack
+ * traces of V8).
+ *
+ * @param bson
+ * @param described
+ */
+export declare function errorOf(bson: any, described: EmbeddedWorkerError): Error;

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERIALIZE_OPTIONS = exports.DB_METHODS = exports.COLLECTION_METHODS = exports.REPLY_BATCH = exports.WORKER_DATA_KEY = void 0;
+exports.encode = encode;
+exports.encodeDocuments = encodeDocuments;
+exports.decodeDocuments = decodeDocuments;
+exports.describeError = describeError;
+exports.errorOf = errorOf;
+const TypeORMError_1 = require("../../error/TypeORMError");
+/**
+ * lakutata: the key of the data of the worker thread of an embedded MongoDB in its workerData.
+ */
+exports.WORKER_DATA_KEY = "lakutataMongoEmbedded";
+/**
+ * lakutata: the documents of a batch of the documents of a find or an aggregation.
+ */
+exports.REPLY_BATCH = 1000;
+/**
+ * lakutata: the methods of the collections the main thread calls with the operation "collection" (the finds and
+ * the aggregations are the operations "find" and "aggregate").
+ */
+exports.COLLECTION_METHODS = new Set([
+    "countDocuments",
+    "count",
+    "estimatedDocumentCount",
+    "distinct",
+    "insertOne",
+    "insertMany",
+    "updateOne",
+    "updateMany",
+    "replaceOne",
+    "deleteOne",
+    "deleteMany",
+    "createIndex",
+    "createIndexes",
+    "indexes",
+    "indexExists",
+    "indexInformation",
+    "dropIndex",
+    "dropIndexes",
+    "isCapped",
+    "bulkWrite",
+    "findOneAndDelete",
+    "findOneAndReplace",
+    "findOneAndUpdate",
+    "rename",
+]);
+/**
+ * lakutata: the methods of the database the main thread calls with the operation "db".
+ */
+exports.DB_METHODS = new Set(["dropDatabase", "dropCollection"]);
+/**
+ * lakutata: the options of the serialization of the calls and their results: the undefined fields dropped (as the
+ * copies of the values of the store drop them; the undefined items of the arrays are null).
+ */
+exports.SERIALIZE_OPTIONS = { ignoreUndefined: true };
+/**
+ * lakutata: the size of the internal buffer of bson, the most it serializes by default.
+ */
+const BSON_BUFFER = 17 * 1024 * 1024;
+/**
+ * lakutata: a value in BSON. One larger than the internal buffer of bson (17 MiB) is serialized with a buffer of its
+ * size (bson keeps it then): the documents are encoded one at a time (encodeDocuments), each of them smaller.
+ *
+ * @param bson
+ * @param value
+ */
+function encode(bson, value) {
+    try {
+        return bson.serialize(value, exports.SERIALIZE_OPTIONS);
+    }
+    catch (error) {
+        const size = bson.calculateObjectSize(value, exports.SERIALIZE_OPTIONS);
+        if (size <= BSON_BUFFER)
+            throw error;
+        return bson.serialize(value, {
+            ...exports.SERIALIZE_OPTIONS,
+            minInternalBufferSize: size,
+        });
+    }
+}
+/**
+ * lakutata: documents in BSON, one after the other.
+ *
+ * @param bson
+ * @param documents
+ */
+function encodeDocuments(bson, documents) {
+    return Buffer.concat(documents.map((document) => encode(bson, document)));
+}
+/**
+ * lakutata: the documents of encodeDocuments.
+ *
+ * @param bson
+ * @param bytes
+ */
+function decodeDocuments(bson, bytes) {
+    const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const documents = [];
+    for (let at = 0; at < buffer.length;) {
+        const size = buffer.readInt32LE(at);
+        documents.push(bson.deserialize(buffer.subarray(at, at + size)));
+        at += size;
+    }
+    return documents;
+}
+/**
+ * lakutata: an error of the worker thread, to send to the main thread.
+ *
+ * @param bson
+ * @param error
+ */
+function describeError(bson, error) {
+    const fields = {};
+    if (error !== null && typeof error === "object")
+        for (const key of Object.keys(error))
+            if (key !== "message" && key !== "stack")
+                fields[key] = error[key];
+    let serialized;
+    try {
+        if (Object.keys(fields).length)
+            serialized = encode(bson, fields);
+    }
+    catch {
+        // Fields that BSON does not hold: the name and the message only
+    }
+    return {
+        name: error?.name ?? "Error",
+        message: error?.message ?? String(error),
+        fields: serialized,
+    };
+}
+/**
+ * lakutata: an error of the worker thread, made again in the main thread: a TypeORMError of its name, its message
+ * and its fields. Made by the async function awaiting the reply, its stack is the one of the call (the async stack
+ * traces of V8).
+ *
+ * @param bson
+ * @param described
+ */
+function errorOf(bson, described) {
+    const error = new TypeORMError_1.TypeORMError(described.message);
+    Object.defineProperty(error, "name", {
+        value: described.name,
+        configurable: true,
+        writable: true,
+    });
+    if (described.fields)
+        Object.assign(error, bson.deserialize(described.fields));
+    const frames = error.stack?.indexOf("\n    at ") ?? -1;
+    if (frames >= 0)
+        error.stack = `${described.name}: ${described.message}${error.stack.slice(frames)}`;
+    return error;
+}
+//# sourceMappingURL=EmbeddedWorkerProtocol.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedWorkerProtocol.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedWorkerProtocol.ts"],"names":[],"mappings":";;;AAqIA,wBAWC;AAQD,0CAKC;AAQD,0CAYC;AAQD,sCAgBC;AAUD,0BAaC;AAhOD,2DAAuD;AAIvD;;GAEG;AACU,QAAA,eAAe,GAAG,uBAAuB,CAAA;AAmEtD;;GAEG;AACU,QAAA,WAAW,GAAG,IAAI,CAAA;AAE/B;;;GAGG;AACU,QAAA,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACtC,gBAAgB;IAChB,OAAO;IACP,wBAAwB;IACxB,UAAU;IACV,WAAW;IACX,YAAY;IACZ,WAAW;IACX,YAAY;IACZ,YAAY;IACZ,WAAW;IACX,YAAY;IACZ,aAAa;IACb,eAAe;IACf,SAAS;IACT,aAAa;IACb,kBAAkB;IAClB,WAAW;IACX,aAAa;IACb,UAAU;IACV,WAAW;IACX,kBAAkB;IAClB,mBAAmB;IACnB,kBAAkB;IAClB,QAAQ;CACX,CAAC,CAAA;AAEF;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,GAAG,CAAC,CAAC,cAAc,EAAE,gBAAgB,CAAC,CAAC,CAAA;AAErE;;;GAGG;AACU,QAAA,iBAAiB,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,CAAA;AAE1D;;GAEG;AACH,MAAM,WAAW,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;AAEpC;;;;;;GAMG;AACH,SAAgB,MAAM,CAAC,IAAS,EAAE,KAAuB;IACrD,IAAI,CAAC;QACD,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,yBAAiB,CAAC,CAAA;IACnD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,EAAE,yBAAiB,CAAC,CAAA;QAC/D,IAAI,IAAI,IAAI,WAAW;YAAE,MAAM,KAAK,CAAA;QACpC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE;YACzB,GAAG,yBAAiB;YACpB,qBAAqB,EAAE,IAAI;SAC9B,CAAC,CAAA;IACN,CAAC;AACL,CAAC;AAED;;;;;GAKG;AACH,SAAgB,eAAe,CAC3B,IAAS,EACT,SAA6B;IAE7B,OAAO,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAA;AAC7E,CAAC;AAED;;;;;GAKG;AACH,SAAgB,eAAe,CAC3B,IAAS,EACT,KAAiB;IAEjB,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAA;IAC5E,MAAM,SAAS,GAAuB,EAAE,CAAA;IACxC,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,MAAM,CAAC,MAAM,GAAI,CAAC;QACpC,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAA;QACnC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,CAAA;QAChE,EAAE,IAAI,IAAI,CAAA;IACd,CAAC;IACD,OAAO,SAAS,CAAA;AACpB,CAAC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,IAAS,EAAE,KAAU;IAC/C,MAAM,MAAM,GAAqB,EAAE,CAAA;IACnC,IAAI,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ;QAC3C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC;YAChC,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,OAAO;gBAAE,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,CAAC,CAAA;IAC1E,IAAI,UAAkC,CAAA;IACtC,IAAI,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM;YAAE,UAAU,GAAG,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IACrE,CAAC;IAAC,MAAM,CAAC;QACL,gEAAgE;IACpE,CAAC;IACD,OAAO;QACH,IAAI,EAAE,KAAK,EAAE,IAAI,IAAI,OAAO;QAC5B,OAAO,EAAE,KAAK,EAAE,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC;QACxC,MAAM,EAAE,UAAU;KACrB,CAAA;AACL,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,OAAO,CAAC,IAAS,EAAE,SAA8B;IAC7D,MAAM,KAAK,GAAG,IAAI,2BAAY,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;IACjD,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE;QACjC,KAAK,EAAE,SAAS,CAAC,IAAI;QACrB,YAAY,EAAE,IAAI;QAClB,QAAQ,EAAE,IAAI;KACjB,CAAC,CAAA;IACF,IAAI,SAAS,CAAC,MAAM;QAChB,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAA;IAC5D,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAA;IACtD,IAAI,MAAM,IAAI,CAAC;QACX,KAAK,CAAC,KAAK,GAAG,GAAG,SAAS,CAAC,IAAI,KAAK,SAAS,CAAC,OAAO,GAAG,KAAK,CAAC,KAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,CAAA;IACxF,OAAO,KAAK,CAAA;AAChB,CAAC","sourcesContent":["import { TypeORMError } from \"../../error/TypeORMError\"\nimport type { EmbeddedStoreOptions } from \"./EmbeddedStore\"\nimport type { EmbeddedDocument } from \"./EmbeddedValues\"\n\n/**\n * lakutata: the key of the data of the worker thread of an embedded MongoDB in its workerData.\n */\nexport const WORKER_DATA_KEY = \"lakutataMongoEmbedded\"\n\n/**\n * lakutata: the data of the worker thread of an embedded MongoDB: the directory of its database (none in memory), the\n * options of its store, and the token of the connection in the file LOCK of the directory (the client removes the\n * LOCK of its connection when the worker thread exits).\n */\nexport interface EmbeddedWorkerData {\n    directory?: string\n    options: EmbeddedStoreOptions\n    token: string\n}\n\n/**\n * lakutata: a call of the worker thread of an embedded MongoDB: its operation, and its arguments in BSON.\n *  - \"collection\": a method of a collection ({ collection, method, args })\n *  - \"db\": a method of the database ({ method, args })\n *  - \"find\": the documents of a find ({ collection, query, projection, sort, skip, limit })\n *  - \"aggregate\": the documents of an aggregation ({ collection, pipeline, options })\n *  - \"open\": a cursor of a find read a batch at a time, and its first batch (as \"find\"); a find not streamed\n *    (isStreamed) replies all its batches, without a cursor\n *  - \"more\": the next batch of a cursor ({ cursor })\n *  - \"kill\": the closing of a cursor ({ cursor })\n *  - \"close\": the closing of the database\n */\nexport interface EmbeddedRequest {\n    id: number\n    /**\n     * The documents of an insertMany (its first argument), each one in BSON (encodeDocuments).\n     */\n    documents?: Uint8Array\n    op:\n        | \"collection\"\n        | \"db\"\n        | \"find\"\n        | \"aggregate\"\n        | \"open\"\n        | \"more\"\n        | \"kill\"\n        | \"close\"\n    payload?: Uint8Array\n}\n\n/**\n * lakutata: the reply of the worker thread to a call (the id 0 is the one of its opening): its result in BSON\n * ({ result }), the documents of a find or an aggregation in batches (encodeDocuments), the id of a cursor and\n * whether it is read to its end, or its error.\n */\nexport interface EmbeddedReply {\n    id: number\n    payload?: Uint8Array\n    batches?: Uint8Array[]\n    cursor?: number\n    done?: boolean\n    error?: EmbeddedWorkerError\n}\n\n/**\n * lakutata: an error of the worker thread, sent to the main thread: its name, its message, and its fields (the code\n * of a duplicate key...) in BSON.\n */\nexport interface EmbeddedWorkerError {\n    name: string\n    message: string\n    fields?: Uint8Array\n}\n\n/**\n * lakutata: the documents of a batch of the documents of a find or an aggregation.\n */\nexport const REPLY_BATCH = 1000\n\n/**\n * lakutata: the methods of the collections the main thread calls with the operation \"collection\" (the finds and\n * the aggregations are the operations \"find\" and \"aggregate\").\n */\nexport const COLLECTION_METHODS = new Set([\n    \"countDocuments\",\n    \"count\",\n    \"estimatedDocumentCount\",\n    \"distinct\",\n    \"insertOne\",\n    \"insertMany\",\n    \"updateOne\",\n    \"updateMany\",\n    \"replaceOne\",\n    \"deleteOne\",\n    \"deleteMany\",\n    \"createIndex\",\n    \"createIndexes\",\n    \"indexes\",\n    \"indexExists\",\n    \"indexInformation\",\n    \"dropIndex\",\n    \"dropIndexes\",\n    \"isCapped\",\n    \"bulkWrite\",\n    \"findOneAndDelete\",\n    \"findOneAndReplace\",\n    \"findOneAndUpdate\",\n    \"rename\",\n])\n\n/**\n * lakutata: the methods of the database the main thread calls with the operation \"db\".\n */\nexport const DB_METHODS = new Set([\"dropDatabase\", \"dropCollection\"])\n\n/**\n * lakutata: the options of the serialization of the calls and their results: the undefined fields dropped (as the\n * copies of the values of the store drop them; the undefined items of the arrays are null).\n */\nexport const SERIALIZE_OPTIONS = { ignoreUndefined: true }\n\n/**\n * lakutata: the size of the internal buffer of bson, the most it serializes by default.\n */\nconst BSON_BUFFER = 17 * 1024 * 1024\n\n/**\n * lakutata: a value in BSON. One larger than the internal buffer of bson (17 MiB) is serialized with a buffer of its\n * size (bson keeps it then): the documents are encoded one at a time (encodeDocuments), each of them smaller.\n *\n * @param bson\n * @param value\n */\nexport function encode(bson: any, value: EmbeddedDocument): Uint8Array {\n    try {\n        return bson.serialize(value, SERIALIZE_OPTIONS)\n    } catch (error) {\n        const size = bson.calculateObjectSize(value, SERIALIZE_OPTIONS)\n        if (size <= BSON_BUFFER) throw error\n        return bson.serialize(value, {\n            ...SERIALIZE_OPTIONS,\n            minInternalBufferSize: size,\n        })\n    }\n}\n\n/**\n * lakutata: documents in BSON, one after the other.\n *\n * @param bson\n * @param documents\n */\nexport function encodeDocuments(\n    bson: any,\n    documents: EmbeddedDocument[],\n): Uint8Array {\n    return Buffer.concat(documents.map((document) => encode(bson, document)))\n}\n\n/**\n * lakutata: the documents of encodeDocuments.\n *\n * @param bson\n * @param bytes\n */\nexport function decodeDocuments(\n    bson: any,\n    bytes: Uint8Array,\n): EmbeddedDocument[] {\n    const buffer = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength)\n    const documents: EmbeddedDocument[] = []\n    for (let at = 0; at < buffer.length; ) {\n        const size = buffer.readInt32LE(at)\n        documents.push(bson.deserialize(buffer.subarray(at, at + size)))\n        at += size\n    }\n    return documents\n}\n\n/**\n * lakutata: an error of the worker thread, to send to the main thread.\n *\n * @param bson\n * @param error\n */\nexport function describeError(bson: any, error: any): EmbeddedWorkerError {\n    const fields: EmbeddedDocument = {}\n    if (error !== null && typeof error === \"object\")\n        for (const key of Object.keys(error))\n            if (key !== \"message\" && key !== \"stack\") fields[key] = error[key]\n    let serialized: Uint8Array | undefined\n    try {\n        if (Object.keys(fields).length) serialized = encode(bson, fields)\n    } catch {\n        // Fields that BSON does not hold: the name and the message only\n    }\n    return {\n        name: error?.name ?? \"Error\",\n        message: error?.message ?? String(error),\n        fields: serialized,\n    }\n}\n\n/**\n * lakutata: an error of the worker thread, made again in the main thread: a TypeORMError of its name, its message\n * and its fields. Made by the async function awaiting the reply, its stack is the one of the call (the async stack\n * traces of V8).\n *\n * @param bson\n * @param described\n */\nexport function errorOf(bson: any, described: EmbeddedWorkerError): Error {\n    const error = new TypeORMError(described.message)\n    Object.defineProperty(error, \"name\", {\n        value: described.name,\n        configurable: true,\n        writable: true,\n    })\n    if (described.fields)\n        Object.assign(error, bson.deserialize(described.fields))\n    const frames = error.stack?.indexOf(\"\\n    at \") ?? -1\n    if (frames >= 0)\n        error.stack = `${described.name}: ${described.message}${error.stack!.slice(frames)}`\n    return error\n}\n"]}

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

@@ -0,0 +1,97 @@
+import type { BaseDataSourceOptions } from "../../data-source/BaseDataSourceOptions";
+/**
+ * lakutata: the options of an embedded MongoDB, a database of the process: its documents in the files of a directory
+ * (the records of their versions appended), found by their _id from an index held in memory (outside the heap of V8),
+ * queried and updated with the semantics of MongoDB (by mingo), in a worker thread by default. It needs the packages
+ * mingo and bson. One process opens a directory: it is locked.
+ */
+export interface MongoEmbeddedDataSourceOptions extends BaseDataSourceOptions {
+    /**
+     * Database type.
+     */
+    readonly type: "mongo-embedded";
+    /**
+     * The directory of the database (created when missing), or ":memory:" (the default) for a database in memory only.
+     */
+    readonly database?: string;
+    /**
+     * When the writes are written to the disk (fsync): "always", before each write resolves (the writes made together
+     * share one); "interval" (the default), every syncInterval, so that a write resolved survives a crash of the process
+     * but up to an interval of writes may be lost on a crash of the system or a power loss; "never", when the system
+     * writes them.
+     */
+    readonly sync?: "always" | "interval" | "never";
+    /**
+     * The interval of the writes to the disk of the sync "interval", in milliseconds.
+     *
+     * @default 100
+     */
+    readonly syncInterval?: number;
+    /**
+     * The memory of the documents cached (read without reading their file again), in bytes, estimated from their size
+     * (about 4 times their BSON); 0 caches none. A scan reads the documents cached when they are all the ones of the
+     * collection.
+     *
+     * @default 67108864 (64 MiB)
+     */
+    readonly cacheSize?: number;
+    /**
+     * When the file of a collection is compacted (its live documents copied to a new file, the writes going on): from
+     * a size (16 MiB by default) when it is a ratio of the bytes of its live documents (2 by default); false compacts
+     * none.
+     */
+    readonly compaction?: false | {
+        minimumSize?: number;
+        ratio?: number;
+    };
+    /**
+     * When the snapshot of a collection (its index of the _id and its indexes, the state of an offset of its file) is
+     * written while it is open, besides its closing: when the bytes written to its file since its snapshot are a size
+     * (64 MiB by default) and a ratio of its file (0.25 by default). The opening after a crash reads its snapshot,
+     * then the records written after it only (else all the records of its file, the indexes built again: 60 s for
+     * 10,000,000 documents of two indexes). A snapshot is written at once, about 1 s for 10,000,000 documents (the
+     * thread of the application waits for it with the option worker false); its size is about the one of the index of
+     * the _id and of the indexes. false writes the snapshots at the closing only.
+     */
+    readonly snapshot?: false | {
+        minimumSize?: number;
+        ratio?: number;
+    };
+    /**
+     * Whether the database runs in a worker thread (the default): its queries, its writes and its files out of the
+     * event loop of the application, which they do not block; their arguments and their results sent between the
+     * threads in BSON (about 20 µs a call, the documents of the results decoded in the thread of the application, a
+     * batch at a time). false runs it in the thread of the application: its calls are faster, and the functions of
+     * JavaScript of its queries ($where, $function, $accumulator), which are not sent to a worker thread, run.
+     *
+     * @default true
+     */
+    readonly worker?: boolean;
+    /**
+     * The limits of the worker thread (the resourceLimits of the workers of Node.js), unset by default: it has then the
+     * ones of the thread of the application (its heap the size of the option --max-old-space-size, or the default of
+     * V8). A worker thread exceeding them is ended, not the process: its calls fail, and its directory is unlocked, to
+     * be opened again. A maxOldGenerationSizeMb of 256 MB or less may end the whole process instead (Node.js 24 runs out
+     * of memory before it ends the worker thread); Bun does not apply them. Not used by the option worker false.
+     */
+    readonly workerResourceLimits?: {
+        /**
+         * The heap of the objects of the worker thread (its old generation), in MB.
+         */
+        readonly maxOldGenerationSizeMb?: number;
+        /**
+         * The heap of the objects created recently (its young generation), in MB.
+         */
+        readonly maxYoungGenerationSizeMb?: number;
+        /**
+         * The memory of the code compiled, in MB.
+         */
+        readonly codeRangeSizeMb?: number;
+        /**
+         * The stack of the worker thread, in MB.
+         *
+         * @default 4
+         */
+        readonly stackSizeMb?: number;
+    };
+}

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=MongoEmbeddedDataSourceOptions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MongoEmbeddedDataSourceOptions.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/MongoEmbeddedDataSourceOptions.ts"],"names":[],"mappings":"","sourcesContent":["import type { BaseDataSourceOptions } from \"../../data-source/BaseDataSourceOptions\"\n\n/**\n * lakutata: the options of an embedded MongoDB, a database of the process: its documents in the files of a directory\n * (the records of their versions appended), found by their _id from an index held in memory (outside the heap of V8),\n * queried and updated with the semantics of MongoDB (by mingo), in a worker thread by default. It needs the packages\n * mingo and bson. One process opens a directory: it is locked.\n */\nexport interface MongoEmbeddedDataSourceOptions extends BaseDataSourceOptions {\n    /**\n     * Database type.\n     */\n    readonly type: \"mongo-embedded\"\n\n    /**\n     * The directory of the database (created when missing), or \":memory:\" (the default) for a database in memory only.\n     */\n    readonly database?: string\n\n    /**\n     * When the writes are written to the disk (fsync): \"always\", before each write resolves (the writes made together\n     * share one); \"interval\" (the default), every syncInterval, so that a write resolved survives a crash of the process\n     * but up to an interval of writes may be lost on a crash of the system or a power loss; \"never\", when the system\n     * writes them.\n     */\n    readonly sync?: \"always\" | \"interval\" | \"never\"\n\n    /**\n     * The interval of the writes to the disk of the sync \"interval\", in milliseconds.\n     *\n     * @default 100\n     */\n    readonly syncInterval?: number\n\n    /**\n     * The memory of the documents cached (read without reading their file again), in bytes, estimated from their size\n     * (about 4 times their BSON); 0 caches none. A scan reads the documents cached when they are all the ones of the\n     * collection.\n     *\n     * @default 67108864 (64 MiB)\n     */\n    readonly cacheSize?: number\n\n    /**\n     * When the file of a collection is compacted (its live documents copied to a new file, the writes going on): from\n     * a size (16 MiB by default) when it is a ratio of the bytes of its live documents (2 by default); false compacts\n     * none.\n     */\n    readonly compaction?: false | { minimumSize?: number; ratio?: number }\n\n    /**\n     * When the snapshot of a collection (its index of the _id and its indexes, the state of an offset of its file) is\n     * written while it is open, besides its closing: when the bytes written to its file since its snapshot are a size\n     * (64 MiB by default) and a ratio of its file (0.25 by default). The opening after a crash reads its snapshot,\n     * then the records written after it only (else all the records of its file, the indexes built again: 60 s for\n     * 10,000,000 documents of two indexes). A snapshot is written at once, about 1 s for 10,000,000 documents (the\n     * thread of the application waits for it with the option worker false); its size is about the one of the index of\n     * the _id and of the indexes. false writes the snapshots at the closing only.\n     */\n    readonly snapshot?: false | { minimumSize?: number; ratio?: number }\n\n    /**\n     * Whether the database runs in a worker thread (the default): its queries, its writes and its files out of the\n     * event loop of the application, which they do not block; their arguments and their results sent between the\n     * threads in BSON (about 20 µs a call, the documents of the results decoded in the thread of the application, a\n     * batch at a time). false runs it in the thread of the application: its calls are faster, and the functions of\n     * JavaScript of its queries ($where, $function, $accumulator), which are not sent to a worker thread, run.\n     *\n     * @default true\n     */\n    readonly worker?: boolean\n\n    /**\n     * The limits of the worker thread (the resourceLimits of the workers of Node.js), unset by default: it has then the\n     * ones of the thread of the application (its heap the size of the option --max-old-space-size, or the default of\n     * V8). A worker thread exceeding them is ended, not the process: its calls fail, and its directory is unlocked, to\n     * be opened again. A maxOldGenerationSizeMb of 256 MB or less may end the whole process instead (Node.js 24 runs out\n     * of memory before it ends the worker thread); Bun does not apply them. Not used by the option worker false.\n     */\n    readonly workerResourceLimits?: {\n        /**\n         * The heap of the objects of the worker thread (its old generation), in MB.\n         */\n        readonly maxOldGenerationSizeMb?: number\n\n        /**\n         * The heap of the objects created recently (its young generation), in MB.\n         */\n        readonly maxYoungGenerationSizeMb?: number\n\n        /**\n         * The memory of the code compiled, in MB.\n         */\n        readonly codeRangeSizeMb?: number\n\n        /**\n         * The stack of the worker thread, in MB.\n         *\n         * @default 4\n         */\n        readonly stackSizeMb?: number\n    }\n}\n"]}

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

@@ -0,0 +1,33 @@
+import { MongoDriver } from "../mongodb/MongoDriver";
+import type { ReturningType } from "../types/ReturningType";
+/**
+ * lakutata: the driver of an embedded MongoDB. It is the driver of MongoDB, its query runner, entity manager and
+ * repositories, with a client of the same API holding the collections in the process: in a worker thread (the option
+ * worker, by default), or in the thread of the application.
+ */
+export declare class MongoEmbeddedDriver extends MongoDriver {
+    /**
+     * The packages of the embedded client: mingo (the semantics of MongoDB) and bson (its types).
+     */
+    embedded: {
+        mingo: any;
+        bson: any;
+    };
+    /**
+     * Opens the database: its files read when they exist, in a worker thread unless the option worker is false.
+     */
+    connect(): Promise<void>;
+    /**
+     * Whether the persistence of the entities may insert them together: the embedded client inserts the documents of a
+     * save with one insertMany (in batches of 1000 documents, each one written as one operation: a failure leaves the
+     * batches before it written), and gives their _id in their order. The query builders, which the other uses of the
+     * returning statements are, are not supported by MongoDB.
+     *
+     * @param returningType
+     */
+    isReturningSqlSupported(returningType?: ReturningType): boolean;
+    /**
+     * Loads mingo and bson; the ObjectId of the entity manager is the one of bson.
+     */
+    protected loadDependencies(): any;
+}

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoEmbeddedDriver = void 0;
+const DriverPackageNotInstalledError_1 = require("../../error/DriverPackageNotInstalledError");
+const DriverPackages_1 = require("../../platform/DriverPackages");
+const ObjectUtils_1 = require("../../util/ObjectUtils");
+const MongoDriver_1 = require("../mongodb/MongoDriver");
+const MongoQueryRunner_1 = require("../mongodb/MongoQueryRunner");
+const EmbeddedClient_1 = require("./EmbeddedClient");
+const EmbeddedWorkerClient_1 = require("./EmbeddedWorkerClient");
+/**
+ * lakutata: the driver of an embedded MongoDB. It is the driver of MongoDB, its query runner, entity manager and
+ * repositories, with a client of the same API holding the collections in the process: in a worker thread (the option
+ * worker, by default), or in the thread of the application.
+ */
+class MongoEmbeddedDriver extends MongoDriver_1.MongoDriver {
+    /**
+     * Opens the database: its files read when they exist, in a worker thread unless the option worker is false.
+     */
+    async connect() {
+        const options = this.options;
+        const storeOptions = {
+            sync: options.sync,
+            syncInterval: options.syncInterval,
+            cacheSize: options.cacheSize,
+            compaction: options.compaction,
+            snapshot: options.snapshot,
+        };
+        const client = options.worker === false
+            ? await EmbeddedClient_1.EmbeddedClient.connect(options.database, storeOptions, this.embedded.mingo, this.embedded.bson)
+            : await EmbeddedWorkerClient_1.EmbeddedWorkerClient.connect(options.database, storeOptions, this.embedded.bson, options.workerResourceLimits);
+        this.queryRunner = new MongoQueryRunner_1.MongoQueryRunner(this.dataSource, client);
+        ObjectUtils_1.ObjectUtils.assign(this.queryRunner, {
+            manager: this.dataSource.manager,
+        });
+    }
+    /**
+     * Whether the persistence of the entities may insert them together: the embedded client inserts the documents of a
+     * save with one insertMany (in batches of 1000 documents, each one written as one operation: a failure leaves the
+     * batches before it written), and gives their _id in their order. The query builders, which the other uses of the
+     * returning statements are, are not supported by MongoDB.
+     *
+     * @param returningType
+     */
+    isReturningSqlSupported(returningType) {
+        return returningType === "insert";
+    }
+    /**
+     * Loads mingo and bson; the ObjectId of the entity manager is the one of bson.
+     */
+    loadDependencies() {
+        const load = (packageName) => {
+            try {
+                return (0, DriverPackages_1.requireDriverPackage)(packageName);
+            }
+            catch {
+                throw new DriverPackageNotInstalledError_1.DriverPackageNotInstalledError("MongoDB (embedded)", packageName);
+            }
+        };
+        const mingo = load("mingo");
+        const bson = load("bson");
+        this.embedded = { mingo, bson };
+        this.mongodb = { ObjectId: bson.ObjectId };
+    }
+}
+exports.MongoEmbeddedDriver = MongoEmbeddedDriver;
+//# sourceMappingURL=MongoEmbeddedDriver.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MongoEmbeddedDriver.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/MongoEmbeddedDriver.ts"],"names":[],"mappings":";;;AAAA,+FAA2F;AAC3F,kEAAoE;AACpE,wDAAoD;AACpD,wDAAoD;AACpD,kEAA8D;AAE9D,qDAAiD;AAEjD,iEAA6D;AAG7D;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,yBAAW;IAMhD;;OAEG;IACH,KAAK,CAAC,OAAO;QACT,MAAM,OAAO,GAAG,IAAI,CAAC,OAAoD,CAAA;QACzE,MAAM,YAAY,GAAyB;YACvC,IAAI,EAAE,OAAO,CAAC,IAAI;YAClB,YAAY,EAAE,OAAO,CAAC,YAAY;YAClC,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,UAAU,EAAE,OAAO,CAAC,UAAU;YAC9B,QAAQ,EAAE,OAAO,CAAC,QAAQ;SAC7B,CAAA;QACD,MAAM,MAAM,GACR,OAAO,CAAC,MAAM,KAAK,KAAK;YACpB,CAAC,CAAC,MAAM,+BAAc,CAAC,OAAO,CACxB,OAAO,CAAC,QAAQ,EAChB,YAAY,EACZ,IAAI,CAAC,QAAQ,CAAC,KAAK,EACnB,IAAI,CAAC,QAAQ,CAAC,IAAI,CACrB;YACH,CAAC,CAAC,MAAM,2CAAoB,CAAC,OAAO,CAC9B,OAAO,CAAC,QAAQ,EAChB,YAAY,EACZ,IAAI,CAAC,QAAQ,CAAC,IAAI,EAClB,OAAO,CAAC,oBAAoB,CAC/B,CAAA;QACX,IAAI,CAAC,WAAW,GAAG,IAAI,mCAAgB,CAAC,IAAI,CAAC,UAAU,EAAE,MAAa,CAAC,CAAA;QACvE,yBAAW,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE;YACjC,OAAO,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO;SACnC,CAAC,CAAA;IACN,CAAC;IAED;;;;;;;OAOG;IACH,uBAAuB,CAAC,aAA6B;QACjD,OAAO,aAAa,KAAK,QAAQ,CAAA;IACrC,CAAC;IAED;;OAEG;IACO,gBAAgB;QACtB,MAAM,IAAI,GAAG,CAAC,WAAmB,EAAE,EAAE;YACjC,IAAI,CAAC;gBACD,OAAO,IAAA,qCAAoB,EAAC,WAAW,CAAC,CAAA;YAC5C,CAAC;YAAC,MAAM,CAAC;gBACL,MAAM,IAAI,+DAA8B,CACpC,oBAAoB,EACpB,WAAW,CACd,CAAA;YACL,CAAC;QACL,CAAC,CAAA;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAA;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAA;QACzB,IAAI,CAAC,QAAQ,GAAG,EAAE,KAAK,EAAE,IAAI,EAAE,CAAA;QAC/B,IAAI,CAAC,OAAO,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAA;IAC9C,CAAC;CACJ;AArED,kDAqEC","sourcesContent":["import { DriverPackageNotInstalledError } from \"../../error/DriverPackageNotInstalledError\"\nimport { requireDriverPackage } from \"../../platform/DriverPackages\"\nimport { ObjectUtils } from \"../../util/ObjectUtils\"\nimport { MongoDriver } from \"../mongodb/MongoDriver\"\nimport { MongoQueryRunner } from \"../mongodb/MongoQueryRunner\"\nimport type { ReturningType } from \"../types/ReturningType\"\nimport { EmbeddedClient } from \"./EmbeddedClient\"\nimport type { EmbeddedStoreOptions } from \"./EmbeddedStore\"\nimport { EmbeddedWorkerClient } from \"./EmbeddedWorkerClient\"\nimport type { MongoEmbeddedDataSourceOptions } from \"./MongoEmbeddedDataSourceOptions\"\n\n/**\n * lakutata: the driver of an embedded MongoDB. It is the driver of MongoDB, its query runner, entity manager and\n * repositories, with a client of the same API holding the collections in the process: in a worker thread (the option\n * worker, by default), or in the thread of the application.\n */\nexport class MongoEmbeddedDriver extends MongoDriver {\n    /**\n     * The packages of the embedded client: mingo (the semantics of MongoDB) and bson (its types).\n     */\n    embedded: { mingo: any; bson: any }\n\n    /**\n     * Opens the database: its files read when they exist, in a worker thread unless the option worker is false.\n     */\n    async connect(): Promise<void> {\n        const options = this.options as unknown as MongoEmbeddedDataSourceOptions\n        const storeOptions: EmbeddedStoreOptions = {\n            sync: options.sync,\n            syncInterval: options.syncInterval,\n            cacheSize: options.cacheSize,\n            compaction: options.compaction,\n            snapshot: options.snapshot,\n        }\n        const client =\n            options.worker === false\n                ? await EmbeddedClient.connect(\n                      options.database,\n                      storeOptions,\n                      this.embedded.mingo,\n                      this.embedded.bson,\n                  )\n                : await EmbeddedWorkerClient.connect(\n                      options.database,\n                      storeOptions,\n                      this.embedded.bson,\n                      options.workerResourceLimits,\n                  )\n        this.queryRunner = new MongoQueryRunner(this.dataSource, client as any)\n        ObjectUtils.assign(this.queryRunner, {\n            manager: this.dataSource.manager,\n        })\n    }\n\n    /**\n     * Whether the persistence of the entities may insert them together: the embedded client inserts the documents of a\n     * save with one insertMany (in batches of 1000 documents, each one written as one operation: a failure leaves the\n     * batches before it written), and gives their _id in their order. The query builders, which the other uses of the\n     * returning statements are, are not supported by MongoDB.\n     *\n     * @param returningType\n     */\n    isReturningSqlSupported(returningType?: ReturningType): boolean {\n        return returningType === \"insert\"\n    }\n\n    /**\n     * Loads mingo and bson; the ObjectId of the entity manager is the one of bson.\n     */\n    protected loadDependencies(): any {\n        const load = (packageName: string) => {\n            try {\n                return requireDriverPackage(packageName)\n            } catch {\n                throw new DriverPackageNotInstalledError(\n                    \"MongoDB (embedded)\",\n                    packageName,\n                )\n            }\n        }\n        const mingo = load(\"mingo\")\n        const bson = load(\"bson\")\n        this.embedded = { mingo, bson }\n        this.mongodb = { ObjectId: bson.ObjectId }\n    }\n}\n"]}