@lakutata/orm 3.0.0 → 3.1.1

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

@@ -0,0 +1,529 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedStore = void 0;
+exports.unlockDirectory = unlockDirectory;
+const tslib_1 = require("tslib");
+const crypto_1 = require("crypto");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+const TypeORMError_1 = require("../../error/TypeORMError");
+const EmbeddedCache_1 = require("./EmbeddedCache");
+const EmbeddedCollectionStore_1 = require("./EmbeddedCollectionStore");
+const EmbeddedFile_1 = require("./EmbeddedFile");
+/**
+ * lakutata: the extension of the files of the collections.
+ */
+const EXTENSION = ".log";
+/**
+ * lakutata: the extension added to the file of a collection for the file of its compaction.
+ */
+const NEXT = ".next";
+/**
+ * lakutata: yields the event loop.
+ */
+function yieldLoop() {
+    return new Promise((resolve) => setImmediate(resolve));
+}
+/**
+ * lakutata: the path of the snapshot of the file of a collection.
+ *
+ * @param file
+ */
+function snapshotOf(file) {
+    return file.slice(0, -EXTENSION.length) + ".snapshot";
+}
+/**
+ * lakutata: the name of the file of a collection: its name (the characters of the names of files) and the hash of
+ * it (the names differing by their case, on the systems ignoring it).
+ *
+ * @param name
+ */
+function fileNameOf(name) {
+    const safe = name.replace(/[^A-Za-z0-9_.-]/g, "_").slice(0, 64);
+    const hash = (0, crypto_1.createHash)("sha1").update(name).digest("hex").slice(0, 8);
+    return `${safe}.${hash}${EXTENSION}`;
+}
+/**
+ * lakutata: whether a process runs.
+ *
+ * @param pid
+ */
+function isRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+/**
+ * lakutata: the content of the file LOCK of a directory opened by a connection: the pid of its process, then the token
+ * of the connection (the connections of a process told apart).
+ *
+ * @param token
+ */
+function lockContent(token) {
+    return `${process.pid}\n${token}`;
+}
+/**
+ * lakutata: removes the file LOCK of a directory when it is the one of a connection (its token).
+ *
+ * @param directory
+ * @param token
+ */
+function unlockDirectory(directory, token) {
+    const lock = path.join(directory, "LOCK");
+    try {
+        if (fs.readFileSync(lock, "utf8") === lockContent(token))
+            fs.rmSync(lock, { force: true });
+    }
+    catch {
+        // No file LOCK
+    }
+}
+/**
+ * lakutata: the collections of an embedded MongoDB: the files of a directory (created when missing, locked by the
+ * process which opens it), or files in memory (":memory:").
+ */
+class EmbeddedStore {
+    /**
+     * @param directory
+     * @param values
+     * @param options
+     * @param token the token of the connection in the file LOCK of the directory
+     */
+    constructor(directory, values, options, token) {
+        this.directory = directory;
+        this.values = values;
+        this.options = options;
+        this.token = token;
+        this.collections = new Map();
+        this.unsynced = new Set();
+        this.waiting = [];
+        this.syncScheduled = false;
+        /**
+         * Whether it is closing or closed: the writes made then are synced by the closing.
+         */
+        this.closing = false;
+        /**
+         * The collections whose compaction copied their documents, ended once no scan reads their previous file and no
+         * index of them is built (endCompactionIfIdle).
+         */
+        this.ending = new Set();
+        this.budget = new EmbeddedCache_1.EmbeddedCacheBudget(options.cacheSize ?? 64 * 1024 * 1024);
+    }
+    /**
+     * Opens a database: its directory locked, the files of its collections read.
+     *
+     * @param directory the directory of the database, or undefined for a database in memory
+     * @param values
+     * @param options
+     * @param token the token of the connection in the file LOCK of the directory (a random one by default)
+     */
+    static open(directory, values, options, token = (0, crypto_1.randomBytes)(8).toString("hex")) {
+        const store = new EmbeddedStore(directory, values, options, token);
+        if (!directory)
+            return store;
+        fs.mkdirSync(directory, { recursive: true });
+        store.lock();
+        try {
+            for (const name of fs.readdirSync(directory)) {
+                if (!name.endsWith(EXTENSION))
+                    continue;
+                const file = path.join(directory, name);
+                const collection = EmbeddedCollectionStore_1.EmbeddedCollectionStore.open(new EmbeddedFile_1.EmbeddedDiskFile(file), values, new EmbeddedCache_1.EmbeddedCollectionCache(store.budget), file, snapshotOf(file));
+                if (collection) {
+                    store.collections.set(collection.name, collection);
+                    store.resumeCompaction(collection, file);
+                }
+                else {
+                    fs.rmSync(file, { force: true });
+                    fs.rmSync(snapshotOf(file), { force: true });
+                    fs.rmSync(file + NEXT, { force: true });
+                }
+            }
+        }
+        catch (error) {
+            store.closeFiles();
+            store.unlock();
+            throw error;
+        }
+        return store;
+    }
+    /**
+     * The names of the collections.
+     */
+    names() {
+        return [...this.collections.keys()];
+    }
+    /**
+     * A collection, created when asked.
+     *
+     * @param name
+     * @param create
+     */
+    collection(name, create) {
+        let collection = this.collections.get(name);
+        if (!collection && create) {
+            collection = EmbeddedCollectionStore_1.EmbeddedCollectionStore.create(name, this.directory
+                ? new EmbeddedFile_1.EmbeddedDiskFile(path.join(this.directory, fileNameOf(name)))
+                : new EmbeddedFile_1.EmbeddedMemoryFile(), this.values, new EmbeddedCache_1.EmbeddedCollectionCache(this.budget));
+            this.collections.set(name, collection);
+        }
+        return collection;
+    }
+    /**
+     * After a write of a collection: resolved once it is written as the option sync tells.
+     *
+     * @param collection
+     */
+    written(collection) {
+        if (this.closing)
+            return Promise.resolve();
+        // The file holding the write, before a compaction it starts makes another one the file of the collection
+        if (this.directory && this.options.sync !== "never")
+            this.unsynced.add(collection.file);
+        this.endCompactionIfIdle(collection);
+        this.compactIfWorth(collection);
+        if (!this.directory)
+            return Promise.resolve();
+        this.snapshotIfWorth(collection);
+        if (this.options.sync === "never")
+            return Promise.resolve();
+        if (this.options.sync === "always")
+            return new Promise((resolve, reject) => {
+                this.waiting.push({ resolve: resolve, reject: reject });
+                if (this.syncScheduled)
+                    return;
+                this.syncScheduled = true;
+                setImmediate(() => {
+                    try {
+                        this.sync();
+                    }
+                    catch {
+                        // the writes waiting for it are rejected
+                    }
+                });
+            });
+        if (!this.timer) {
+            this.timer = setTimeout(() => {
+                this.timer = undefined;
+                try {
+                    this.sync();
+                }
+                catch {
+                    // the next write or the closing syncs again
+                }
+            }, this.options.syncInterval ?? 100);
+            this.timer.unref?.();
+        }
+        return Promise.resolve();
+    }
+    /**
+     * After a scan of a collection, or the build of an index of it, ended: the compaction they held back ends, or
+     * starts when it is worth it.
+     *
+     * @param collection
+     */
+    scanned(collection) {
+        if (this.closing || this.collections.get(collection.name) !== collection)
+            return;
+        this.endCompactionIfIdle(collection);
+        this.compactIfWorth(collection);
+    }
+    /**
+     * Removes a collection and its files; whether it existed. Its compaction running stops; its cursors and its writes
+     * running fail (its files closed).
+     *
+     * @param name
+     */
+    drop(name) {
+        const collection = this.collections.get(name);
+        if (!collection)
+            return false;
+        this.collections.delete(name);
+        this.ending.delete(collection);
+        this.unsynced.delete(collection.file);
+        if (collection.previous)
+            this.unsynced.delete(collection.previous);
+        // Its file: the previous one during a compaction (the file of the compaction is the current one)
+        const file = collection.previous ?? collection.file;
+        collection.close();
+        if (file instanceof EmbeddedFile_1.EmbeddedDiskFile) {
+            fs.rmSync(file.path, { force: true });
+            fs.rmSync(file.path + NEXT, { force: true });
+            fs.rmSync(snapshotOf(file.path), { force: true });
+        }
+        return true;
+    }
+    /**
+     * Removes all the collections.
+     */
+    clear() {
+        for (const name of this.names())
+            this.drop(name);
+    }
+    /**
+     * Closes the database: its files written to the disk, the snapshots of the collections changed written (a
+     * snapshot failing to be written is left as it was: the records written after it are read again), its files
+     * closed, its directory unlocked.
+     */
+    async close() {
+        this.closing = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        for (const collection of this.collections.values()) {
+            await collection.building;
+            await collection.compacting;
+        }
+        // The compactions whose documents are copied ended (their scans end with the files)
+        for (const collection of this.ending)
+            this.endCopiedCompaction(collection);
+        this.ending.clear();
+        try {
+            if (this.directory)
+                for (const collection of this.collections.values())
+                    this.unsynced.add(collection.file);
+            this.sync();
+            for (const collection of this.collections.values())
+                if (collection.changed &&
+                    !collection.previous &&
+                    collection.file instanceof EmbeddedFile_1.EmbeddedDiskFile) {
+                    const snapshot = snapshotOf(collection.file.path);
+                    try {
+                        collection.writeSnapshot(snapshot);
+                    }
+                    catch {
+                        fs.rmSync(`${snapshot}.tmp`, { force: true });
+                    }
+                }
+        }
+        finally {
+            this.closeFiles();
+            this.unlock();
+        }
+    }
+    /**
+     * Writes the files written to the disk, and resolves the writes waiting for it.
+     */
+    sync() {
+        this.syncScheduled = false;
+        const waiting = this.waiting;
+        this.waiting = [];
+        try {
+            for (const file of this.unsynced)
+                file.sync();
+            this.unsynced.clear();
+        }
+        catch (error) {
+            for (const write of waiting)
+                write.reject(error);
+            throw error;
+        }
+        for (const write of waiting)
+            write.resolve();
+    }
+    /**
+     * Writes the snapshot of a collection (at the next turn of the event loop) 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
+     * then reads the records written after it only. Its file is synced first (the snapshot is the state of an offset
+     * of it). The snapshot is written at once (about 1 s for 10,000,000 documents of two indexes), not while the
+     * collection is compacted, an index of it built, or the database closed.
+     *
+     * @param collection
+     */
+    snapshotIfWorth(collection) {
+        const options = this.options.snapshot;
+        if (options === false ||
+            collection.snapshotScheduled ||
+            !(collection.file instanceof EmbeddedFile_1.EmbeddedDiskFile))
+            return;
+        const appended = collection.file.size - collection.snapshotOffset;
+        if (appended <
+            Math.max(options?.minimumSize ?? 64 * 1024 * 1024, (options?.ratio ?? 0.25) * collection.file.size))
+            return;
+        collection.snapshotScheduled = true;
+        setImmediate(() => {
+            collection.snapshotScheduled = false;
+            if (this.closing ||
+                this.collections.get(collection.name) !== collection ||
+                collection.previous ||
+                collection.building)
+                return;
+            const file = collection.file;
+            const snapshot = snapshotOf(file.path);
+            try {
+                file.sync();
+                collection.writeSnapshot(snapshot);
+            }
+            catch {
+                // The previous snapshot (or none) is read with the records after it
+                fs.rmSync(`${snapshot}.tmp`, { force: true });
+            }
+        });
+    }
+    /**
+     * Starts the compaction of a collection when its file is worth it (and none runs).
+     *
+     * @param collection
+     */
+    compactIfWorth(collection) {
+        const options = this.options.compaction;
+        // Not while one runs or ends (previous), nor while an index is built: the build reads one file
+        if (options === false ||
+            collection.compacting ||
+            collection.previous ||
+            collection.building)
+            return;
+        if (!collection.isWorthCompacting(options?.minimumSize ?? 16 * 1024 * 1024, options?.ratio ?? 2) ||
+            // Not while its file is scanned (a cursor read): the next write tries again
+            collection.isScanned())
+            return;
+        collection.compacting = this.compact(collection).finally(() => {
+            collection.compacting = undefined;
+        });
+    }
+    /**
+     * Compacts a collection: its live documents copied to a new file, a batch between two yields of the event loop,
+     * the writes made meanwhile written to it; then, once no scan reads the previous file (endCompactionIfIdle), the
+     * new file written to the disk and renamed over the previous one. A compaction failing leaves the collection on its
+     * two files (the next opening resumes it); the collection dropped or closed meanwhile stops it.
+     *
+     * @param collection
+     */
+    async compact(collection) {
+        collection.beginCompaction(collection.file instanceof EmbeddedFile_1.EmbeddedDiskFile
+            ? new EmbeddedFile_1.EmbeddedDiskFile(collection.file.path + NEXT)
+            : new EmbeddedFile_1.EmbeddedMemoryFile());
+        try {
+            for (const _ of collection.copyLiveDocuments()) {
+                await yieldLoop();
+                // Its files closed meanwhile: the copy goes no further (it returns the generator)
+                if (collection.closed)
+                    return;
+            }
+        }
+        catch {
+            // Its two files are read until the next opening resumes it
+            return;
+        }
+        this.ending.add(collection);
+        this.endCompactionIfIdle(collection);
+    }
+    /**
+     * Ends the compaction of a collection whose documents are copied, unless a scan reads its two files (in the last
+     * SCAN_TIMEOUT) or an index of it is built from them: the end of the last of them ends it (scanned), else its next
+     * write or the closing.
+     *
+     * @param collection
+     */
+    endCompactionIfIdle(collection) {
+        if (!this.ending.has(collection) ||
+            collection.building ||
+            collection.isScanned())
+            return;
+        this.ending.delete(collection);
+        this.endCopiedCompaction(collection);
+    }
+    /**
+     * Ends a compaction whose documents are copied; failing, it leaves the collection on its two files (the next
+     * opening resumes it).
+     *
+     * @param collection
+     */
+    endCopiedCompaction(collection) {
+        try {
+            this.endCompaction(collection);
+        }
+        catch {
+            // Its two files are read until the next opening resumes it
+        }
+    }
+    /**
+     * Ends the compaction of a collection: the new file written to the disk, the previous one closed, the new one
+     * renamed over it (its snapshot removed: it is the one of the previous file). The directory is not synced: a
+     * rename lost by a crash leaves the two files, and the next opening resumes the compaction; a snapshot left is the
+     * one of the previous file, refused by its id.
+     *
+     * @param collection
+     */
+    endCompaction(collection) {
+        const next = collection.file;
+        if (!(next instanceof EmbeddedFile_1.EmbeddedDiskFile)) {
+            collection.endCompaction();
+            return;
+        }
+        const previous = collection.previous;
+        const path = previous.path;
+        next.sync();
+        // The writes of the previous file not synced yet: the new file, synced, holds them
+        this.unsynced.delete(previous);
+        collection.endCompaction();
+        fs.renameSync(next.path, path);
+        next.path = path;
+        fs.rmSync(snapshotOf(path), { force: true });
+        collection.snapshotOffset = 0;
+        // The file of the collection from now on, synced by the next sync as the files written
+        this.unsynced.add(next);
+    }
+    /**
+     * Resumes the compaction of a collection cut by a crash, when its file is there (a file cut when it was created is
+     * removed).
+     *
+     * @param collection
+     * @param file the path of the file of the collection
+     */
+    resumeCompaction(collection, file) {
+        if (!fs.existsSync(file + NEXT))
+            return;
+        const next = new EmbeddedFile_1.EmbeddedDiskFile(file + NEXT);
+        try {
+            collection.resumeCompaction(next, file + NEXT);
+        }
+        catch (error) {
+            if (collection.file === next)
+                throw error;
+            // Its header cut: nothing was written to it
+            next.close();
+            fs.rmSync(file + NEXT, { force: true });
+            return;
+        }
+        this.endCompaction(collection);
+    }
+    closeFiles() {
+        for (const collection of this.collections.values())
+            collection.close();
+        this.collections.clear();
+    }
+    /**
+     * Locks the directory: its file LOCK holds the pid of the process and the token of the connection, removed when the
+     * process does not run any more.
+     */
+    lock() {
+        const lock = path.join(this.directory, "LOCK");
+        for (let attempt = 0;; attempt++) {
+            try {
+                const descriptor = fs.openSync(lock, "wx");
+                fs.writeSync(descriptor, lockContent(this.token));
+                fs.closeSync(descriptor);
+                return;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST" || attempt > 0)
+                    throw error;
+                const pid = Number(fs.readFileSync(lock, "utf8").split("\n")[0]);
+                if (pid && isRunning(pid))
+                    throw new TypeORMError_1.TypeORMError(`The database ${this.directory} of mongo-embedded is opened by ${pid === process.pid ? "this process" : `the process ${pid}`}`);
+                fs.rmSync(lock, { force: true });
+            }
+        }
+    }
+    unlock() {
+        if (this.directory)
+            unlockDirectory(this.directory, this.token);
+    }
+}
+exports.EmbeddedStore = EmbeddedStore;
+//# sourceMappingURL=EmbeddedStore.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedStore.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedStore.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash, randomBytes } from \"crypto\"\nimport * as fs from \"fs\"\nimport * as path from \"path\"\nimport { TypeORMError } from \"../../error/TypeORMError\"\nimport { EmbeddedCacheBudget, EmbeddedCollectionCache } from \"./EmbeddedCache\"\nimport { EmbeddedCollectionStore } from \"./EmbeddedCollectionStore\"\nimport type { EmbeddedFile } from \"./EmbeddedFile\"\nimport { EmbeddedDiskFile, EmbeddedMemoryFile } from \"./EmbeddedFile\"\nimport type { EmbeddedValues } from \"./EmbeddedValues\"\n\n/**\n * lakutata: when the writes are written to the disk (fsync): after each write (\"always\", the writes made together\n * sharing one), every interval (\"interval\"), or when the system does (\"never\").\n */\nexport type EmbeddedSync = \"always\" | \"interval\" | \"never\"\n\n/**\n * lakutata: the options of the storage of an embedded MongoDB.\n */\nexport interface EmbeddedStoreOptions {\n    sync?: EmbeddedSync\n    syncInterval?: number\n    cacheSize?: number\n    compaction?: false | { minimumSize?: number; ratio?: number }\n    snapshot?: false | { minimumSize?: number; ratio?: number }\n}\n\n/**\n * lakutata: the extension of the files of the collections.\n */\nconst EXTENSION = \".log\"\n\n/**\n * lakutata: the extension added to the file of a collection for the file of its compaction.\n */\nconst NEXT = \".next\"\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 path of the snapshot of the file of a collection.\n *\n * @param file\n */\nfunction snapshotOf(file: string): string {\n    return file.slice(0, -EXTENSION.length) + \".snapshot\"\n}\n\n/**\n * lakutata: the name of the file of a collection: its name (the characters of the names of files) and the hash of\n * it (the names differing by their case, on the systems ignoring it).\n *\n * @param name\n */\nfunction fileNameOf(name: string): string {\n    const safe = name.replace(/[^A-Za-z0-9_.-]/g, \"_\").slice(0, 64)\n    const hash = createHash(\"sha1\").update(name).digest(\"hex\").slice(0, 8)\n    return `${safe}.${hash}${EXTENSION}`\n}\n\n/**\n * lakutata: whether a process runs.\n *\n * @param pid\n */\nfunction isRunning(pid: number): boolean {\n    try {\n        process.kill(pid, 0)\n        return true\n    } catch (error) {\n        return error.code === \"EPERM\"\n    }\n}\n\n/**\n * lakutata: the content of the file LOCK of a directory opened by a connection: the pid of its process, then the token\n * of the connection (the connections of a process told apart).\n *\n * @param token\n */\nfunction lockContent(token: string): string {\n    return `${process.pid}\\n${token}`\n}\n\n/**\n * lakutata: removes the file LOCK of a directory when it is the one of a connection (its token).\n *\n * @param directory\n * @param token\n */\nexport function unlockDirectory(directory: string, token: string): void {\n    const lock = path.join(directory, \"LOCK\")\n    try {\n        if (fs.readFileSync(lock, \"utf8\") === lockContent(token))\n            fs.rmSync(lock, { force: true })\n    } catch {\n        // No file LOCK\n    }\n}\n\n/**\n * lakutata: the collections of an embedded MongoDB: the files of a directory (created when missing, locked by the\n * process which opens it), or files in memory (\":memory:\").\n */\nexport class EmbeddedStore {\n    protected readonly collections = new Map<string, EmbeddedCollectionStore>()\n\n    protected readonly unsynced = new Set<EmbeddedFile>()\n\n    protected waiting: { resolve: () => void; reject: (error: Error) => void }[] =\n        []\n\n    protected syncScheduled = false\n\n    protected timer?: ReturnType<typeof setTimeout>\n\n    /**\n     * Whether it is closing or closed: the writes made then are synced by the closing.\n     */\n    protected closing = false\n\n    /**\n     * The collections whose compaction copied their documents, ended once no scan reads their previous file and no\n     * index of them is built (endCompactionIfIdle).\n     */\n    protected readonly ending = new Set<EmbeddedCollectionStore>()\n\n    protected readonly budget: EmbeddedCacheBudget\n\n    /**\n     * @param directory\n     * @param values\n     * @param options\n     * @param token the token of the connection in the file LOCK of the directory\n     */\n    protected constructor(\n        readonly directory: string | undefined,\n        readonly values: EmbeddedValues,\n        readonly options: EmbeddedStoreOptions,\n        protected readonly token: string,\n    ) {\n        this.budget = new EmbeddedCacheBudget(\n            options.cacheSize ?? 64 * 1024 * 1024,\n        )\n    }\n\n    /**\n     * Opens a database: its directory locked, the files of its collections read.\n     *\n     * @param directory the directory of the database, or undefined for a database in memory\n     * @param values\n     * @param options\n     * @param token the token of the connection in the file LOCK of the directory (a random one by default)\n     */\n    static open(\n        directory: string | undefined,\n        values: EmbeddedValues,\n        options: EmbeddedStoreOptions,\n        token = randomBytes(8).toString(\"hex\"),\n    ): EmbeddedStore {\n        const store = new EmbeddedStore(directory, values, options, token)\n        if (!directory) return store\n        fs.mkdirSync(directory, { recursive: true })\n        store.lock()\n        try {\n            for (const name of fs.readdirSync(directory)) {\n                if (!name.endsWith(EXTENSION)) continue\n                const file = path.join(directory, name)\n                const collection = EmbeddedCollectionStore.open(\n                    new EmbeddedDiskFile(file),\n                    values,\n                    new EmbeddedCollectionCache(store.budget),\n                    file,\n                    snapshotOf(file),\n                )\n                if (collection) {\n                    store.collections.set(collection.name, collection)\n                    store.resumeCompaction(collection, file)\n                } else {\n                    fs.rmSync(file, { force: true })\n                    fs.rmSync(snapshotOf(file), { force: true })\n                    fs.rmSync(file + NEXT, { force: true })\n                }\n            }\n        } catch (error) {\n            store.closeFiles()\n            store.unlock()\n            throw error\n        }\n        return store\n    }\n\n    /**\n     * The names of the collections.\n     */\n    names(): string[] {\n        return [...this.collections.keys()]\n    }\n\n    /**\n     * A collection, created when asked.\n     *\n     * @param name\n     * @param create\n     */\n    collection(\n        name: string,\n        create: boolean,\n    ): EmbeddedCollectionStore | undefined {\n        let collection = this.collections.get(name)\n        if (!collection && create) {\n            collection = EmbeddedCollectionStore.create(\n                name,\n                this.directory\n                    ? new EmbeddedDiskFile(\n                          path.join(this.directory, fileNameOf(name)),\n                      )\n                    : new EmbeddedMemoryFile(),\n                this.values,\n                new EmbeddedCollectionCache(this.budget),\n            )\n            this.collections.set(name, collection)\n        }\n        return collection\n    }\n\n    /**\n     * After a write of a collection: resolved once it is written as the option sync tells.\n     *\n     * @param collection\n     */\n    written(collection: EmbeddedCollectionStore): Promise<void> {\n        if (this.closing) return Promise.resolve()\n        // The file holding the write, before a compaction it starts makes another one the file of the collection\n        if (this.directory && this.options.sync !== \"never\")\n            this.unsynced.add(collection.file)\n        this.endCompactionIfIdle(collection)\n        this.compactIfWorth(collection)\n        if (!this.directory) return Promise.resolve()\n        this.snapshotIfWorth(collection)\n        if (this.options.sync === \"never\") return Promise.resolve()\n        if (this.options.sync === \"always\")\n            return new Promise((resolve, reject) => {\n                this.waiting.push({ resolve: resolve, reject: reject })\n                if (this.syncScheduled) return\n                this.syncScheduled = true\n                setImmediate(() => {\n                    try {\n                        this.sync()\n                    } catch {\n                        // the writes waiting for it are rejected\n                    }\n                })\n            })\n        if (!this.timer) {\n            this.timer = setTimeout(() => {\n                this.timer = undefined\n                try {\n                    this.sync()\n                } catch {\n                    // the next write or the closing syncs again\n                }\n            }, this.options.syncInterval ?? 100)\n            this.timer.unref?.()\n        }\n        return Promise.resolve()\n    }\n\n    /**\n     * After a scan of a collection, or the build of an index of it, ended: the compaction they held back ends, or\n     * starts when it is worth it.\n     *\n     * @param collection\n     */\n    scanned(collection: EmbeddedCollectionStore): void {\n        if (this.closing || this.collections.get(collection.name) !== collection)\n            return\n        this.endCompactionIfIdle(collection)\n        this.compactIfWorth(collection)\n    }\n\n    /**\n     * Removes a collection and its files; whether it existed. Its compaction running stops; its cursors and its writes\n     * running fail (its files closed).\n     *\n     * @param name\n     */\n    drop(name: string): boolean {\n        const collection = this.collections.get(name)\n        if (!collection) return false\n        this.collections.delete(name)\n        this.ending.delete(collection)\n        this.unsynced.delete(collection.file)\n        if (collection.previous) this.unsynced.delete(collection.previous)\n        // Its file: the previous one during a compaction (the file of the compaction is the current one)\n        const file = collection.previous ?? collection.file\n        collection.close()\n        if (file instanceof EmbeddedDiskFile) {\n            fs.rmSync(file.path, { force: true })\n            fs.rmSync(file.path + NEXT, { force: true })\n            fs.rmSync(snapshotOf(file.path), { force: true })\n        }\n        return true\n    }\n\n    /**\n     * Removes all the collections.\n     */\n    clear(): void {\n        for (const name of this.names()) this.drop(name)\n    }\n\n    /**\n     * Closes the database: its files written to the disk, the snapshots of the collections changed written (a\n     * snapshot failing to be written is left as it was: the records written after it are read again), its files\n     * closed, its directory unlocked.\n     */\n    async close(): Promise<void> {\n        this.closing = true\n        if (this.timer) clearTimeout(this.timer)\n        this.timer = undefined\n        for (const collection of this.collections.values()) {\n            await collection.building\n            await collection.compacting\n        }\n        // The compactions whose documents are copied ended (their scans end with the files)\n        for (const collection of this.ending) this.endCopiedCompaction(collection)\n        this.ending.clear()\n        try {\n            if (this.directory)\n                for (const collection of this.collections.values())\n                    this.unsynced.add(collection.file)\n            this.sync()\n            for (const collection of this.collections.values())\n                if (\n                    collection.changed &&\n                    !collection.previous &&\n                    collection.file instanceof EmbeddedDiskFile\n                ) {\n                    const snapshot = snapshotOf(collection.file.path)\n                    try {\n                        collection.writeSnapshot(snapshot)\n                    } catch {\n                        fs.rmSync(`${snapshot}.tmp`, { force: true })\n                    }\n                }\n        } finally {\n            this.closeFiles()\n            this.unlock()\n        }\n    }\n\n    /**\n     * Writes the files written to the disk, and resolves the writes waiting for it.\n     */\n    protected sync(): void {\n        this.syncScheduled = false\n        const waiting = this.waiting\n        this.waiting = []\n        try {\n            for (const file of this.unsynced) file.sync()\n            this.unsynced.clear()\n        } catch (error) {\n            for (const write of waiting) write.reject(error)\n            throw error\n        }\n        for (const write of waiting) write.resolve()\n    }\n\n    /**\n     * Writes the snapshot of a collection (at the next turn of the event loop) when the bytes written to its file since\n     * its snapshot are a size (64 MiB by default) and a ratio of its file (0.25 by default): the opening after a crash\n     * then reads the records written after it only. Its file is synced first (the snapshot is the state of an offset\n     * of it). The snapshot is written at once (about 1 s for 10,000,000 documents of two indexes), not while the\n     * collection is compacted, an index of it built, or the database closed.\n     *\n     * @param collection\n     */\n    protected snapshotIfWorth(collection: EmbeddedCollectionStore): void {\n        const options = this.options.snapshot\n        if (\n            options === false ||\n            collection.snapshotScheduled ||\n            !(collection.file instanceof EmbeddedDiskFile)\n        )\n            return\n        const appended = collection.file.size - collection.snapshotOffset\n        if (\n            appended <\n            Math.max(\n                options?.minimumSize ?? 64 * 1024 * 1024,\n                (options?.ratio ?? 0.25) * collection.file.size,\n            )\n        )\n            return\n        collection.snapshotScheduled = true\n        setImmediate(() => {\n            collection.snapshotScheduled = false\n            if (\n                this.closing ||\n                this.collections.get(collection.name) !== collection ||\n                collection.previous ||\n                collection.building\n            )\n                return\n            const file = collection.file as EmbeddedDiskFile\n            const snapshot = snapshotOf(file.path)\n            try {\n                file.sync()\n                collection.writeSnapshot(snapshot)\n            } catch {\n                // The previous snapshot (or none) is read with the records after it\n                fs.rmSync(`${snapshot}.tmp`, { force: true })\n            }\n        })\n    }\n\n    /**\n     * Starts the compaction of a collection when its file is worth it (and none runs).\n     *\n     * @param collection\n     */\n    protected compactIfWorth(collection: EmbeddedCollectionStore): void {\n        const options = this.options.compaction\n        // Not while one runs or ends (previous), nor while an index is built: the build reads one file\n        if (\n            options === false ||\n            collection.compacting ||\n            collection.previous ||\n            collection.building\n        )\n            return\n        if (\n            !collection.isWorthCompacting(\n                options?.minimumSize ?? 16 * 1024 * 1024,\n                options?.ratio ?? 2,\n            ) ||\n            // Not while its file is scanned (a cursor read): the next write tries again\n            collection.isScanned()\n        )\n            return\n        collection.compacting = this.compact(collection).finally(() => {\n            collection.compacting = undefined\n        })\n    }\n\n    /**\n     * Compacts a collection: its live documents copied to a new file, a batch between two yields of the event loop,\n     * the writes made meanwhile written to it; then, once no scan reads the previous file (endCompactionIfIdle), the\n     * new file written to the disk and renamed over the previous one. A compaction failing leaves the collection on its\n     * two files (the next opening resumes it); the collection dropped or closed meanwhile stops it.\n     *\n     * @param collection\n     */\n    protected async compact(collection: EmbeddedCollectionStore): Promise<void> {\n        collection.beginCompaction(\n            collection.file instanceof EmbeddedDiskFile\n                ? new EmbeddedDiskFile(collection.file.path + NEXT)\n                : new EmbeddedMemoryFile(),\n        )\n        try {\n            for (const _ of collection.copyLiveDocuments()) {\n                await yieldLoop()\n                // Its files closed meanwhile: the copy goes no further (it returns the generator)\n                if (collection.closed) return\n            }\n        } catch {\n            // Its two files are read until the next opening resumes it\n            return\n        }\n        this.ending.add(collection)\n        this.endCompactionIfIdle(collection)\n    }\n\n    /**\n     * Ends the compaction of a collection whose documents are copied, unless a scan reads its two files (in the last\n     * SCAN_TIMEOUT) or an index of it is built from them: the end of the last of them ends it (scanned), else its next\n     * write or the closing.\n     *\n     * @param collection\n     */\n    protected endCompactionIfIdle(collection: EmbeddedCollectionStore): void {\n        if (\n            !this.ending.has(collection) ||\n            collection.building ||\n            collection.isScanned()\n        )\n            return\n        this.ending.delete(collection)\n        this.endCopiedCompaction(collection)\n    }\n\n    /**\n     * Ends a compaction whose documents are copied; failing, it leaves the collection on its two files (the next\n     * opening resumes it).\n     *\n     * @param collection\n     */\n    protected endCopiedCompaction(collection: EmbeddedCollectionStore): void {\n        try {\n            this.endCompaction(collection)\n        } catch {\n            // Its two files are read until the next opening resumes it\n        }\n    }\n\n    /**\n     * Ends the compaction of a collection: the new file written to the disk, the previous one closed, the new one\n     * renamed over it (its snapshot removed: it is the one of the previous file). The directory is not synced: a\n     * rename lost by a crash leaves the two files, and the next opening resumes the compaction; a snapshot left is the\n     * one of the previous file, refused by its id.\n     *\n     * @param collection\n     */\n    protected endCompaction(collection: EmbeddedCollectionStore): void {\n        const next = collection.file\n        if (!(next instanceof EmbeddedDiskFile)) {\n            collection.endCompaction()\n            return\n        }\n        const previous = collection.previous as EmbeddedDiskFile\n        const path = previous.path\n        next.sync()\n        // The writes of the previous file not synced yet: the new file, synced, holds them\n        this.unsynced.delete(previous)\n        collection.endCompaction()\n        fs.renameSync(next.path, path)\n        next.path = path\n        fs.rmSync(snapshotOf(path), { force: true })\n        collection.snapshotOffset = 0\n        // The file of the collection from now on, synced by the next sync as the files written\n        this.unsynced.add(next)\n    }\n\n    /**\n     * Resumes the compaction of a collection cut by a crash, when its file is there (a file cut when it was created is\n     * removed).\n     *\n     * @param collection\n     * @param file the path of the file of the collection\n     */\n    protected resumeCompaction(\n        collection: EmbeddedCollectionStore,\n        file: string,\n    ): void {\n        if (!fs.existsSync(file + NEXT)) return\n        const next = new EmbeddedDiskFile(file + NEXT)\n        try {\n            collection.resumeCompaction(next, file + NEXT)\n        } catch (error) {\n            if (collection.file === next) throw error\n            // Its header cut: nothing was written to it\n            next.close()\n            fs.rmSync(file + NEXT, { force: true })\n            return\n        }\n        this.endCompaction(collection)\n    }\n\n    protected closeFiles(): void {\n        for (const collection of this.collections.values()) collection.close()\n        this.collections.clear()\n    }\n\n    /**\n     * Locks the directory: its file LOCK holds the pid of the process and the token of the connection, removed when the\n     * process does not run any more.\n     */\n    protected lock(): void {\n        const lock = path.join(this.directory!, \"LOCK\")\n        for (let attempt = 0; ; attempt++) {\n            try {\n                const descriptor = fs.openSync(lock, \"wx\")\n                fs.writeSync(descriptor, lockContent(this.token))\n                fs.closeSync(descriptor)\n                return\n            } catch (error) {\n                if (error.code !== \"EEXIST\" || attempt > 0) throw error\n                const pid = Number(fs.readFileSync(lock, \"utf8\").split(\"\\n\")[0])\n                if (pid && isRunning(pid))\n                    throw new TypeORMError(\n                        `The database ${this.directory} of mongo-embedded is opened by ${pid === process.pid ? \"this process\" : `the process ${pid}`}`,\n                    )\n                fs.rmSync(lock, { force: true })\n            }\n        }\n    }\n\n    protected unlock(): void {\n        if (this.directory) unlockDirectory(this.directory, this.token)\n    }\n}\n"]}

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

@@ -0,0 +1,58 @@
+/**
+ * lakutata: a document of an embedded collection.
+ */
+export type EmbeddedDocument = {
+    [key: string]: any;
+};
+/**
+ * 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).
+ */
+export declare class EmbeddedValues {
+    readonly bson: any;
+    readonly mingo: any;
+    constructor(bson: any, mingo: any);
+    /**
+     * 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: any): any;
+    /**
+     * The value at a path of a document.
+     *
+     * @param document
+     * @param path
+     */
+    valueAt(document: EmbeddedDocument, path: string): any;
+    /**
+     * 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: any): Buffer;
+    /**
+     * 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: Buffer, start?: number): Buffer;
+    /**
+     * Serializes a document, its _id first.
+     *
+     * @param document
+     */
+    serialize(document: EmbeddedDocument): Buffer;
+    /**
+     * Deserializes a document.
+     *
+     * @param data
+     */
+    deserialize(data: Uint8Array): EmbeddedDocument;
+    protected numberKey(value: number): Buffer;
+}