@lakutata/orm 3.0.0 → 3.1.1

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

@@ -0,0 +1,100 @@
+import type { EmbeddedBound } from "./EmbeddedBTree";
+import type { EmbeddedCollectionStore, EmbeddedIndex } from "./EmbeddedCollectionStore";
+import type { EmbeddedDocument } from "./EmbeddedValues";
+/**
+ * lakutata: a range of the keys of an index.
+ */
+export interface EmbeddedRange {
+    lower?: EmbeddedBound;
+    upper?: EmbeddedBound;
+}
+/**
+ * lakutata: how the documents a filter may match are found: by their _id, by the ranges of an index, or by a scan of
+ * the collection. Every document the filter matches is among them (the filter tests them then). An exact plan gives
+ * the documents the filter matches and no other, once each (a count needs no document).
+ */
+export type EmbeddedPlan = {
+    kind: "id";
+    ids: any[];
+    exact: boolean;
+} | {
+    kind: "index";
+    index: string;
+    ranges: EmbeddedRange[];
+    exact: boolean;
+    multikey: boolean;
+} | {
+    kind: "scan";
+    exact: boolean;
+};
+/**
+ * lakutata: a condition of a field on which an index may be used: an equality, a list of values, or a range; complete
+ * when it is all the condition of the field (no other operator of it left to the filter).
+ */
+type Condition = {
+    complete: boolean;
+} & ({
+    kind: "equal";
+    values: any[];
+} | {
+    kind: "range";
+    lower?: {
+        value: any;
+        inclusive: boolean;
+    };
+    upper?: {
+        value: any;
+        inclusive: boolean;
+    };
+});
+/**
+ * lakutata: plans the queries of a collection: the conditions of the fields of a filter (its fields and the ones of its
+ * $and) on which its indexes may be used, without dropping a document the filter matches. An index is used for the
+ * equalities and the lists of values ($eq, $in) of the values of a type it orders, other than null (which matches the
+ * documents missing the field), and for the ranges of an ascending index ($gt, $gte, $lt, $lte); the other operators
+ * ($ne, $nin, $not, $exists, $regex...) are left to the filter. An index of which a document has several keys keeps
+ * one bound of a range (its two bounds may be met by different items of an array), the filter testing the documents.
+ */
+export declare class EmbeddedPlanner {
+    protected readonly collection: EmbeddedCollectionStore;
+    constructor(collection: EmbeddedCollectionStore);
+    /**
+     * The plan of a filter.
+     *
+     * @param filter
+     */
+    plan(filter: EmbeddedDocument): EmbeddedPlan;
+    /**
+     * The index giving the documents in the order of a sort of one field, if any: an ascending or descending index of
+     * that field first, of which no document has several keys, not sparse (the documents missing the field are
+     * sorted too). Its walk is reversed when the sort is in the other direction.
+     *
+     * @param sort
+     */
+    sortIndex(sort: EmbeddedDocument | undefined): {
+        index: string;
+        reverse: boolean;
+    } | undefined;
+    /**
+     * The plan of a condition on the first field of an index, if it may be used.
+     *
+     * @param index
+     * @param condition
+     */
+    protected indexPlan(index: EmbeddedIndex, condition: Condition): EmbeddedPlan | undefined;
+    /**
+     * The conditions of the fields of a filter (its fields, and the ones of the objects of its $and) on which an index
+     * may be used.
+     *
+     * @param filter
+     */
+    protected conditionsOf(filter: EmbeddedDocument): Map<string, Condition>;
+    /**
+     * The condition of a value of a filter on which an index may be used, if any.
+     *
+     * @param value
+     */
+    protected conditionOf(value: any): Condition | undefined;
+    protected isPlainObject(value: any): boolean;
+}
+export {};

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

@@ -0,0 +1,261 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddedPlanner = void 0;
+/**
+ * lakutata: the range operators of the queries of MongoDB.
+ */
+const RANGE_OPERATORS = ["$gt", "$gte", "$lt", "$lte"];
+/**
+ * lakutata: the smallest bytes greater than all the bytes starting with some (undefined when they are all 0xff).
+ *
+ * @param bytes
+ */
+function after(bytes) {
+    for (let index = bytes.length - 1; index >= 0; index--)
+        if (bytes[index] !== 0xff) {
+            const next = Buffer.from(bytes.subarray(0, index + 1));
+            next[index]++;
+            return next;
+        }
+    return undefined;
+}
+/**
+ * lakutata: plans the queries of a collection: the conditions of the fields of a filter (its fields and the ones of its
+ * $and) on which its indexes may be used, without dropping a document the filter matches. An index is used for the
+ * equalities and the lists of values ($eq, $in) of the values of a type it orders, other than null (which matches the
+ * documents missing the field), and for the ranges of an ascending index ($gt, $gte, $lt, $lte); the other operators
+ * ($ne, $nin, $not, $exists, $regex...) are left to the filter. An index of which a document has several keys keeps
+ * one bound of a range (its two bounds may be met by different items of an array), the filter testing the documents.
+ */
+class EmbeddedPlanner {
+    constructor(collection) {
+        this.collection = collection;
+    }
+    /**
+     * The plan of a filter.
+     *
+     * @param filter
+     */
+    plan(filter) {
+        const conditions = this.conditionsOf(filter);
+        const fields = Object.keys(filter).filter((key) => !key.startsWith("$"));
+        const alone = fields.length === 1 && Object.keys(filter).length === 1;
+        const ids = conditions.get("_id");
+        if (ids && ids.kind === "equal")
+            return { kind: "id", ids: ids.values, exact: alone && ids.complete };
+        let best;
+        for (const index of this.collection.indexes) {
+            const [path] = Object.keys(index.key);
+            const condition = conditions.get(path);
+            if (!condition)
+                continue;
+            const plan = this.indexPlan(index, condition);
+            if (!plan)
+                continue;
+            plan.exact =
+                alone &&
+                    condition.complete &&
+                    Object.keys(index.key).length === 1 &&
+                    fields[0] === path &&
+                    plan.exact;
+            const score = condition.kind === "equal" ? (index.unique ? 3 : 2) : 1;
+            if (!best || score > best.score)
+                best = { plan: plan, score: score };
+        }
+        return (best?.plan ?? {
+            kind: "scan",
+            exact: Object.keys(filter).length === 0,
+        });
+    }
+    /**
+     * The index giving the documents in the order of a sort of one field, if any: an ascending or descending index of
+     * that field first, of which no document has several keys, not sparse (the documents missing the field are
+     * sorted too). Its walk is reversed when the sort is in the other direction.
+     *
+     * @param sort
+     */
+    sortIndex(sort) {
+        if (!sort)
+            return undefined;
+        const fields = Object.keys(sort);
+        if (fields.length !== 1)
+            return undefined;
+        const direction = sort[fields[0]] === -1 || sort[fields[0]] === "-1" ? -1 : 1;
+        for (const index of this.collection.indexes) {
+            const [path] = Object.keys(index.key);
+            if (path !== fields[0] ||
+                index.sparse ||
+                this.collection.multikey.has(index.name))
+                continue;
+            const indexDirection = index.key[path] === -1 || index.key[path] === "-1" ? -1 : 1;
+            return { index: index.name, reverse: direction !== indexDirection };
+        }
+        return undefined;
+    }
+    /**
+     * The plan of a condition on the first field of an index, if it may be used.
+     *
+     * @param index
+     * @param condition
+     */
+    indexPlan(index, condition) {
+        const encoding = this.collection.encoding;
+        const [path] = Object.keys(index.key);
+        const descending = index.key[path] === -1 || index.key[path] === "-1";
+        const multikey = this.collection.multikey.has(index.name);
+        if (condition.kind === "equal") {
+            const ranges = [];
+            for (const value of condition.values) {
+                const prefix = encoding.direct(encoding.encode(value), index.key[path]);
+                const end = after(prefix);
+                ranges.push({
+                    lower: { key: prefix, inclusive: true },
+                    upper: end ? { key: end, inclusive: false } : undefined,
+                });
+            }
+            ranges.sort((a, b) => Buffer.compare(a.lower.key, b.lower.key));
+            return {
+                kind: "index",
+                index: index.name,
+                // Each value once (a $in may repeat one, 1 and 1.0 are one key): the ranges of the values, each one
+                // the keys of its prefix (self-delimiting), do not overlap
+                ranges: ranges.filter((range, position) => !position ||
+                    Buffer.compare(range.lower.key, ranges[position - 1].lower.key) !== 0),
+                exact: true,
+                multikey: multikey,
+            };
+        }
+        if (descending)
+            return undefined;
+        let { lower, upper } = condition;
+        let exact = true;
+        // The items of an array may meet the two bounds apart: one of them is kept
+        if (multikey && lower && upper) {
+            upper = undefined;
+            exact = false;
+        }
+        const bound = (lower ?? upper).value;
+        const tag = encoding.encode(bound)[0];
+        const range = {};
+        if (lower) {
+            const key = encoding.encode(lower.value);
+            range.lower = lower.inclusive
+                ? { key: key, inclusive: true }
+                : { key: after(key), inclusive: true };
+        }
+        else
+            range.lower = { key: Buffer.of(tag), inclusive: true };
+        if (upper && encoding.encode(upper.value)[0] === tag) {
+            const key = encoding.encode(upper.value);
+            const end = after(key);
+            range.upper = upper.inclusive
+                ? end
+                    ? { key: end, inclusive: false }
+                    : undefined
+                : { key: key, inclusive: false };
+        }
+        else {
+            // The values of the type of the bound only, as MongoDB compares them
+            range.upper = { key: Buffer.of(tag + 1), inclusive: false };
+            if (upper)
+                exact = false;
+        }
+        return {
+            kind: "index",
+            index: index.name,
+            ranges: [range],
+            exact: exact,
+            multikey: multikey,
+        };
+    }
+    /**
+     * The conditions of the fields of a filter (its fields, and the ones of the objects of its $and) on which an index
+     * may be used.
+     *
+     * @param filter
+     */
+    conditionsOf(filter) {
+        const conditions = new Map();
+        const add = (query) => {
+            for (const path of Object.keys(query)) {
+                if (path === "$and" && Array.isArray(query.$and)) {
+                    for (const item of query.$and)
+                        if (this.isPlainObject(item))
+                            add(item);
+                    continue;
+                }
+                if (path.startsWith("$") || conditions.has(path))
+                    continue;
+                const condition = this.conditionOf(query[path]);
+                if (condition)
+                    conditions.set(path, condition);
+            }
+        };
+        add(filter);
+        return conditions;
+    }
+    /**
+     * The condition of a value of a filter on which an index may be used, if any.
+     *
+     * @param value
+     */
+    conditionOf(value) {
+        const encoding = this.collection.encoding;
+        const usable = (item) => item !== null && item !== undefined && encoding.isOrdered(item);
+        if (!this.isPlainObject(value))
+            return usable(value)
+                ? { kind: "equal", values: [value], complete: true }
+                : undefined;
+        const operators = Object.keys(value);
+        // An object compared as it is, not by operators
+        if (!operators.length || operators.some((key) => !key.startsWith("$")))
+            return undefined;
+        if ("$eq" in value && usable(value.$eq))
+            return {
+                kind: "equal",
+                values: [value.$eq],
+                complete: operators.length === 1,
+            };
+        if (Array.isArray(value.$in) &&
+            value.$in.length &&
+            value.$in.every(usable))
+            return {
+                kind: "equal",
+                values: value.$in,
+                complete: operators.length === 1,
+            };
+        const range = {
+            kind: "range",
+            complete: true,
+        };
+        for (const operator of operators) {
+            if (!RANGE_OPERATORS.includes(operator) || !usable(value[operator])) {
+                range.complete = false;
+                continue;
+            }
+            const bound = {
+                value: value[operator],
+                inclusive: operator.endsWith("e"),
+            };
+            if (operator.startsWith("$g")) {
+                if (range.lower)
+                    range.complete = false;
+                range.lower ??= bound;
+            }
+            else {
+                if (range.upper)
+                    range.complete = false;
+                range.upper ??= bound;
+            }
+        }
+        return range.lower || range.upper ? range : undefined;
+    }
+    isPlainObject(value) {
+        if (value === null || typeof value !== "object")
+            return false;
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+}
+exports.EmbeddedPlanner = EmbeddedPlanner;
+//# sourceMappingURL=EmbeddedPlanner.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"EmbeddedPlanner.js","sourceRoot":"","sources":["../../../../../vendor/typeorm/driver/mongo-embedded/EmbeddedPlanner.ts"],"names":[],"mappings":"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","sourcesContent":["import type { EmbeddedBound } from \"./EmbeddedBTree\"\nimport type {\n    EmbeddedCollectionStore,\n    EmbeddedIndex,\n} from \"./EmbeddedCollectionStore\"\nimport type { EmbeddedDocument } from \"./EmbeddedValues\"\n\n/**\n * lakutata: a range of the keys of an index.\n */\nexport interface EmbeddedRange {\n    lower?: EmbeddedBound\n    upper?: EmbeddedBound\n}\n\n/**\n * lakutata: how the documents a filter may match are found: by their _id, by the ranges of an index, or by a scan of\n * the collection. Every document the filter matches is among them (the filter tests them then). An exact plan gives\n * the documents the filter matches and no other, once each (a count needs no document).\n */\nexport type EmbeddedPlan =\n    | { kind: \"id\"; ids: any[]; exact: boolean }\n    | {\n          kind: \"index\"\n          index: string\n          ranges: EmbeddedRange[]\n          exact: boolean\n          multikey: boolean\n      }\n    | { kind: \"scan\"; exact: boolean }\n\n/**\n * lakutata: a condition of a field on which an index may be used: an equality, a list of values, or a range; complete\n * when it is all the condition of the field (no other operator of it left to the filter).\n */\ntype Condition = { complete: boolean } & (\n    | { kind: \"equal\"; values: any[] }\n    | {\n          kind: \"range\"\n          lower?: { value: any; inclusive: boolean }\n          upper?: { value: any; inclusive: boolean }\n      }\n)\n\n/**\n * lakutata: the range operators of the queries of MongoDB.\n */\nconst RANGE_OPERATORS = [\"$gt\", \"$gte\", \"$lt\", \"$lte\"]\n\n/**\n * lakutata: the smallest bytes greater than all the bytes starting with some (undefined when they are all 0xff).\n *\n * @param bytes\n */\nfunction after(bytes: Buffer): Buffer | undefined {\n    for (let index = bytes.length - 1; index >= 0; index--)\n        if (bytes[index] !== 0xff) {\n            const next = Buffer.from(bytes.subarray(0, index + 1))\n            next[index]++\n            return next\n        }\n    return undefined\n}\n\n/**\n * lakutata: plans the queries of a collection: the conditions of the fields of a filter (its fields and the ones of its\n * $and) on which its indexes may be used, without dropping a document the filter matches. An index is used for the\n * equalities and the lists of values ($eq, $in) of the values of a type it orders, other than null (which matches the\n * documents missing the field), and for the ranges of an ascending index ($gt, $gte, $lt, $lte); the other operators\n * ($ne, $nin, $not, $exists, $regex...) are left to the filter. An index of which a document has several keys keeps\n * one bound of a range (its two bounds may be met by different items of an array), the filter testing the documents.\n */\nexport class EmbeddedPlanner {\n    constructor(protected readonly collection: EmbeddedCollectionStore) {}\n\n    /**\n     * The plan of a filter.\n     *\n     * @param filter\n     */\n    plan(filter: EmbeddedDocument): EmbeddedPlan {\n        const conditions = this.conditionsOf(filter)\n        const fields = Object.keys(filter).filter((key) => !key.startsWith(\"$\"))\n        const alone = fields.length === 1 && Object.keys(filter).length === 1\n        const ids = conditions.get(\"_id\")\n        if (ids && ids.kind === \"equal\")\n            return { kind: \"id\", ids: ids.values, exact: alone && ids.complete }\n        let best: { plan: EmbeddedPlan; score: number } | undefined\n        for (const index of this.collection.indexes) {\n            const [path] = Object.keys(index.key)\n            const condition = conditions.get(path)\n            if (!condition) continue\n            const plan = this.indexPlan(index, condition)\n            if (!plan) continue\n            plan.exact =\n                alone &&\n                condition.complete &&\n                Object.keys(index.key).length === 1 &&\n                fields[0] === path &&\n                plan.exact\n            const score =\n                condition.kind === \"equal\" ? (index.unique ? 3 : 2) : 1\n            if (!best || score > best.score) best = { plan: plan, score: score }\n        }\n        return (\n            best?.plan ?? {\n                kind: \"scan\",\n                exact: Object.keys(filter).length === 0,\n            }\n        )\n    }\n\n    /**\n     * The index giving the documents in the order of a sort of one field, if any: an ascending or descending index of\n     * that field first, of which no document has several keys, not sparse (the documents missing the field are\n     * sorted too). Its walk is reversed when the sort is in the other direction.\n     *\n     * @param sort\n     */\n    sortIndex(\n        sort: EmbeddedDocument | undefined,\n    ): { index: string; reverse: boolean } | undefined {\n        if (!sort) return undefined\n        const fields = Object.keys(sort)\n        if (fields.length !== 1) return undefined\n        const direction = sort[fields[0]] === -1 || sort[fields[0]] === \"-1\" ? -1 : 1\n        for (const index of this.collection.indexes) {\n            const [path] = Object.keys(index.key)\n            if (\n                path !== fields[0] ||\n                index.sparse ||\n                this.collection.multikey.has(index.name)\n            )\n                continue\n            const indexDirection =\n                index.key[path] === -1 || index.key[path] === \"-1\" ? -1 : 1\n            return { index: index.name, reverse: direction !== indexDirection }\n        }\n        return undefined\n    }\n\n    /**\n     * The plan of a condition on the first field of an index, if it may be used.\n     *\n     * @param index\n     * @param condition\n     */\n    protected indexPlan(\n        index: EmbeddedIndex,\n        condition: Condition,\n    ): EmbeddedPlan | undefined {\n        const encoding = this.collection.encoding\n        const [path] = Object.keys(index.key)\n        const descending = index.key[path] === -1 || index.key[path] === \"-1\"\n        const multikey = this.collection.multikey.has(index.name)\n        if (condition.kind === \"equal\") {\n            const ranges: EmbeddedRange[] = []\n            for (const value of condition.values) {\n                const prefix = encoding.direct(\n                    encoding.encode(value),\n                    index.key[path],\n                )\n                const end = after(prefix)\n                ranges.push({\n                    lower: { key: prefix, inclusive: true },\n                    upper: end ? { key: end, inclusive: false } : undefined,\n                })\n            }\n            ranges.sort((a, b) => Buffer.compare(a.lower!.key, b.lower!.key))\n            return {\n                kind: \"index\",\n                index: index.name,\n                // Each value once (a $in may repeat one, 1 and 1.0 are one key): the ranges of the values, each one\n                // the keys of its prefix (self-delimiting), do not overlap\n                ranges: ranges.filter(\n                    (range, position) =>\n                        !position ||\n                        Buffer.compare(\n                            range.lower!.key,\n                            ranges[position - 1].lower!.key,\n                        ) !== 0,\n                ),\n                exact: true,\n                multikey: multikey,\n            }\n        }\n        if (descending) return undefined\n        let { lower, upper } = condition\n        let exact = true\n        // The items of an array may meet the two bounds apart: one of them is kept\n        if (multikey && lower && upper) {\n            upper = undefined\n            exact = false\n        }\n        const bound = (lower ?? upper)!.value\n        const tag = encoding.encode(bound)[0]\n        const range: EmbeddedRange = {}\n        if (lower) {\n            const key = encoding.encode(lower.value)\n            range.lower = lower.inclusive\n                ? { key: key, inclusive: true }\n                : { key: after(key)!, inclusive: true }\n        } else range.lower = { key: Buffer.of(tag), inclusive: true }\n        if (upper && encoding.encode(upper.value)[0] === tag) {\n            const key = encoding.encode(upper.value)\n            const end = after(key)\n            range.upper = upper.inclusive\n                ? end\n                    ? { key: end, inclusive: false }\n                    : undefined\n                : { key: key, inclusive: false }\n        } else {\n            // The values of the type of the bound only, as MongoDB compares them\n            range.upper = { key: Buffer.of(tag + 1), inclusive: false }\n            if (upper) exact = false\n        }\n        return {\n            kind: \"index\",\n            index: index.name,\n            ranges: [range],\n            exact: exact,\n            multikey: multikey,\n        }\n    }\n\n    /**\n     * The conditions of the fields of a filter (its fields, and the ones of the objects of its $and) on which an index\n     * may be used.\n     *\n     * @param filter\n     */\n    protected conditionsOf(filter: EmbeddedDocument): Map<string, Condition> {\n        const conditions = new Map<string, Condition>()\n        const add = (query: EmbeddedDocument) => {\n            for (const path of Object.keys(query)) {\n                if (path === \"$and\" && Array.isArray(query.$and)) {\n                    for (const item of query.$and)\n                        if (this.isPlainObject(item)) add(item)\n                    continue\n                }\n                if (path.startsWith(\"$\") || conditions.has(path)) continue\n                const condition = this.conditionOf(query[path])\n                if (condition) conditions.set(path, condition)\n            }\n        }\n        add(filter)\n        return conditions\n    }\n\n    /**\n     * The condition of a value of a filter on which an index may be used, if any.\n     *\n     * @param value\n     */\n    protected conditionOf(value: any): Condition | undefined {\n        const encoding = this.collection.encoding\n        const usable = (item: any) =>\n            item !== null && item !== undefined && encoding.isOrdered(item)\n        if (!this.isPlainObject(value))\n            return usable(value)\n                ? { kind: \"equal\", values: [value], complete: true }\n                : undefined\n        const operators = Object.keys(value)\n        // An object compared as it is, not by operators\n        if (!operators.length || operators.some((key) => !key.startsWith(\"$\")))\n            return undefined\n        if (\"$eq\" in value && usable(value.$eq))\n            return {\n                kind: \"equal\",\n                values: [value.$eq],\n                complete: operators.length === 1,\n            }\n        if (\n            Array.isArray(value.$in) &&\n            value.$in.length &&\n            value.$in.every(usable)\n        )\n            return {\n                kind: \"equal\",\n                values: value.$in,\n                complete: operators.length === 1,\n            }\n        const range: Extract<Condition, { kind: \"range\" }> = {\n            kind: \"range\",\n            complete: true,\n        }\n        for (const operator of operators) {\n            if (!RANGE_OPERATORS.includes(operator) || !usable(value[operator])) {\n                range.complete = false\n                continue\n            }\n            const bound = {\n                value: value[operator],\n                inclusive: operator.endsWith(\"e\"),\n            }\n            if (operator.startsWith(\"$g\")) {\n                if (range.lower) range.complete = false\n                range.lower ??= bound\n            } else {\n                if (range.upper) range.complete = false\n                range.upper ??= bound\n            }\n        }\n        return range.lower || range.upper ? range : undefined\n    }\n\n    protected isPlainObject(value: any): boolean {\n        if (value === null || typeof value !== \"object\") return false\n        const prototype = Object.getPrototypeOf(value)\n        return prototype === Object.prototype || prototype === null\n    }\n}\n"]}

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

@@ -0,0 +1,185 @@
+import { EmbeddedCacheBudget } from "./EmbeddedCache";
+import { EmbeddedCollectionStore } from "./EmbeddedCollectionStore";
+import type { EmbeddedFile } from "./EmbeddedFile";
+import type { EmbeddedValues } from "./EmbeddedValues";
+/**
+ * lakutata: when the writes are written to the disk (fsync): after each write ("always", the writes made together
+ * sharing one), every interval ("interval"), or when the system does ("never").
+ */
+export type EmbeddedSync = "always" | "interval" | "never";
+/**
+ * lakutata: the options of the storage of an embedded MongoDB.
+ */
+export interface EmbeddedStoreOptions {
+    sync?: EmbeddedSync;
+    syncInterval?: number;
+    cacheSize?: number;
+    compaction?: false | {
+        minimumSize?: number;
+        ratio?: number;
+    };
+    snapshot?: false | {
+        minimumSize?: number;
+        ratio?: number;
+    };
+}
+/**
+ * lakutata: removes the file LOCK of a directory when it is the one of a connection (its token).
+ *
+ * @param directory
+ * @param token
+ */
+export declare function unlockDirectory(directory: string, token: string): void;
+/**
+ * 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:").
+ */
+export declare class EmbeddedStore {
+    readonly directory: string | undefined;
+    readonly values: EmbeddedValues;
+    readonly options: EmbeddedStoreOptions;
+    protected readonly token: string;
+    protected readonly collections: Map<string, EmbeddedCollectionStore>;
+    protected readonly unsynced: Set<EmbeddedFile>;
+    protected waiting: {
+        resolve: () => void;
+        reject: (error: Error) => void;
+    }[];
+    protected syncScheduled: boolean;
+    protected timer?: ReturnType<typeof setTimeout>;
+    /**
+     * Whether it is closing or closed: the writes made then are synced by the closing.
+     */
+    protected closing: boolean;
+    /**
+     * The collections whose compaction copied their documents, ended once no scan reads their previous file and no
+     * index of them is built (endCompactionIfIdle).
+     */
+    protected readonly ending: Set<EmbeddedCollectionStore>;
+    protected readonly budget: EmbeddedCacheBudget;
+    /**
+     * @param directory
+     * @param values
+     * @param options
+     * @param token the token of the connection in the file LOCK of the directory
+     */
+    protected constructor(directory: string | undefined, values: EmbeddedValues, options: EmbeddedStoreOptions, token: string);
+    /**
+     * 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: string | undefined, values: EmbeddedValues, options: EmbeddedStoreOptions, token?: string): EmbeddedStore;
+    /**
+     * The names of the collections.
+     */
+    names(): string[];
+    /**
+     * A collection, created when asked.
+     *
+     * @param name
+     * @param create
+     */
+    collection(name: string, create: boolean): EmbeddedCollectionStore | undefined;
+    /**
+     * After a write of a collection: resolved once it is written as the option sync tells.
+     *
+     * @param collection
+     */
+    written(collection: EmbeddedCollectionStore): Promise<void>;
+    /**
+     * 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: EmbeddedCollectionStore): void;
+    /**
+     * 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: string): boolean;
+    /**
+     * Removes all the collections.
+     */
+    clear(): void;
+    /**
+     * 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.
+     */
+    close(): Promise<void>;
+    /**
+     * Writes the files written to the disk, and resolves the writes waiting for it.
+     */
+    protected sync(): void;
+    /**
+     * 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
+     */
+    protected snapshotIfWorth(collection: EmbeddedCollectionStore): void;
+    /**
+     * Starts the compaction of a collection when its file is worth it (and none runs).
+     *
+     * @param collection
+     */
+    protected compactIfWorth(collection: EmbeddedCollectionStore): void;
+    /**
+     * 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
+     */
+    protected compact(collection: EmbeddedCollectionStore): Promise<void>;
+    /**
+     * 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
+     */
+    protected endCompactionIfIdle(collection: EmbeddedCollectionStore): void;
+    /**
+     * Ends a compaction whose documents are copied; failing, it leaves the collection on its two files (the next
+     * opening resumes it).
+     *
+     * @param collection
+     */
+    protected endCopiedCompaction(collection: EmbeddedCollectionStore): void;
+    /**
+     * 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
+     */
+    protected endCompaction(collection: EmbeddedCollectionStore): void;
+    /**
+     * 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
+     */
+    protected resumeCompaction(collection: EmbeddedCollectionStore, file: string): void;
+    protected closeFiles(): void;
+    /**
+     * 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.
+     */
+    protected lock(): void;
+    protected unlock(): void;
+}