@lakutata/orm 3.0.0 → 3.1.1

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

@@ -0,0 +1,411 @@
+import { TypeORMError } from "../../error/TypeORMError";
+import type { EmbeddedChange, EmbeddedCollectionStore, EmbeddedWriteError } from "./EmbeddedCollectionStore";
+import type { EmbeddedStoreOptions } from "./EmbeddedStore";
+import { EmbeddedStore } from "./EmbeddedStore";
+import type { EmbeddedDocument } from "./EmbeddedValues";
+import { EmbeddedValues } from "./EmbeddedValues";
+/**
+ * lakutata: a $group run on the documents a batch at a time (its stages before it on each batch, then its $group),
+ * the groups of the batches merged by a $group of their results (the arrays of $push concatenated, the ones of
+ * $addToSet united), then completed (the averages divided, the fields in the order of the $group), then the rest of
+ * the pipeline.
+ */
+interface BatchedGroup {
+    batch: EmbeddedDocument[];
+    merge: EmbeddedDocument[];
+    complete: EmbeddedDocument[];
+    rest: EmbeddedDocument[];
+    /**
+     * Its results without a document: none, but the count 0 of a stage $count (as mingo counts).
+     */
+    empty: EmbeddedDocument[];
+}
+/**
+ * lakutata: whether the documents of a find are read a batch at a time by next() (a stream): without an order (its
+ * documents are sorted together), with a skip and a limit of counts, the limit none or more than a batch (a few
+ * documents are read at once, by their _id or an index).
+ *
+ * @param order
+ * @param skipped
+ * @param limited
+ */
+export declare function isStreamed(order: EmbeddedDocument | undefined, skipped: number | undefined, limited: number | undefined): boolean;
+/**
+ * lakutata: the results of a query of an embedded collection, read with the API of the cursors of MongoDB. TypeORM
+ * sets their transform, applied to each document read. toArray() reads them at once; next() reads them a batch at a
+ * time when they stream (batches()), else at once; toArray() after next() gives the ones not given yet.
+ */
+export declare abstract class EmbeddedResults {
+    transform?: (document: EmbeddedDocument) => any;
+    /**
+     * The documents read and not given yet (transformed), none before a read.
+     */
+    protected buffer?: any[];
+    /**
+     * The batches of the documents not read yet, while they stream.
+     */
+    protected stream?: AsyncIterator<EmbeddedDocument[]>;
+    toArray(): Promise<any[]>;
+    next(): Promise<any | null>;
+    hasNext(): Promise<boolean>;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncGenerator<any>;
+    /**
+     * The documents, transformed.
+     */
+    protected read(): Promise<any[]>;
+    /**
+     * Reads documents not given yet, unless they are all read: the stream begun at the first read.
+     */
+    protected fill(): Promise<void>;
+    /**
+     * The next batch of the stream, transformed; undefined once it ended.
+     */
+    protected nextBatch(): Promise<any[] | undefined>;
+    /**
+     * The batches of the documents read by next(), when they stream; undefined when they are read at once.
+     */
+    protected batches(): AsyncIterator<EmbeddedDocument[]> | undefined;
+    /**
+     * The documents of the results, the caller's own.
+     */
+    protected abstract documents(): Promise<EmbeddedDocument[]>;
+}
+/**
+ * lakutata: the cursor of a find of an embedded collection: its filter (replaced by filter()), projection, order,
+ * skip and limit, applied as MongoDB applies them.
+ */
+export declare class EmbeddedFindCursor extends EmbeddedResults {
+    protected readonly collection: EmbeddedCollection;
+    protected query: EmbeddedDocument;
+    protected projection?: EmbeddedDocument;
+    protected order?: EmbeddedDocument;
+    protected skipped: number;
+    protected limited: number;
+    constructor(collection: EmbeddedCollection, query: EmbeddedDocument);
+    filter(query: EmbeddedDocument): this;
+    project(projection: EmbeddedDocument): this;
+    sort(order: EmbeddedDocument): this;
+    skip(count: number): this;
+    limit(count: number): this;
+    protected documents(): Promise<EmbeddedDocument[]>;
+    protected projected(documents: EmbeddedDocument[]): EmbeddedDocument[];
+    /**
+     * The batches of its documents (copies, projected), read as they are asked when they stream (isStreamed); the
+     * documents written while they are read may be missed or, while the collection is compacted, read twice
+     * (EmbeddedCollectionStore.documents).
+     */
+    streamedBatches(): AsyncIterator<EmbeddedDocument[]> | undefined;
+    protected batches(): AsyncIterator<EmbeddedDocument[]> | undefined;
+    protected streamed(): AsyncGenerator<EmbeddedDocument[]>;
+}
+/**
+ * lakutata: the results of an aggregation of an embedded collection, or of a list of documents.
+ */
+export declare class EmbeddedArrayCursor extends EmbeddedResults {
+    protected readonly compute: () => Promise<EmbeddedDocument[]>;
+    constructor(compute: () => Promise<EmbeddedDocument[]>);
+    protected documents(): Promise<EmbeddedDocument[]>;
+}
+/**
+ * lakutata: a collection of an embedded MongoDB, with the methods of the collections of MongoDB that TypeORM calls.
+ * Its writes find their documents a batch at a time (by their _id, an index or a scan, the event loop yielded between
+ * the batches), then read each document of a batch again, test it and write the batch at once, as the other
+ * operations change them meanwhile: a write of many documents is several operations. They wait for the build of an
+ * index of the collection (building), and write at once once it is built, with no await between.
+ */
+export declare class EmbeddedCollection {
+    readonly collectionName: string;
+    readonly store: EmbeddedStore;
+    constructor(collectionName: string, store: EmbeddedStore);
+    get values(): EmbeddedValues;
+    /**
+     * The documents matching a filter, up to a limit: copies, the caller's own, unless they are not to be changed.
+     *
+     * @param query
+     * @param limit
+     * @param copy whether they are copies (else shared with the store)
+     */
+    matching(query?: EmbeddedDocument, limit?: number, copy?: boolean): Promise<EmbeddedDocument[]>;
+    find(query?: EmbeddedDocument, options?: EmbeddedDocument): EmbeddedFindCursor;
+    findOne(query?: EmbeddedDocument, options?: EmbeddedDocument): Promise<any>;
+    countDocuments(query?: EmbeddedDocument, options?: EmbeddedDocument): Promise<number>;
+    count(query?: EmbeddedDocument, options?: EmbeddedDocument): Promise<number>;
+    estimatedDocumentCount(): Promise<number>;
+    distinct(key: string, query?: EmbeddedDocument): Promise<any[]>;
+    aggregate(pipeline: EmbeddedDocument[], options?: EmbeddedDocument): EmbeddedArrayCursor;
+    /**
+     * The results of a pipeline whose $group runs in batches: each batch of the documents matching the filter grouped,
+     * the groups merged, then completed, then the rest of the pipeline run on them.
+     *
+     * @param filter
+     * @param batched
+     * @param options
+     */
+    protected groupedInBatches(filter: EmbeddedDocument | undefined, batched: BatchedGroup, options: EmbeddedDocument): Promise<EmbeddedDocument[]>;
+    /**
+     * The documents matching a filter, in batches (candidates: the event loop yielded between them), shared with the
+     * store (not to be changed).
+     *
+     * @param query
+     */
+    matchingBatches(query?: EmbeddedDocument): AsyncGenerator<EmbeddedDocument[]>;
+    insertOne(document: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        insertedId: any;
+    }>;
+    /**
+     * Inserts documents as MongoDB inserts them: their _id added when missing (to the documents given), written in
+     * batches of 1000 (each one an operation, the event loop yielded between them). A document of which a key is a
+     * duplicate is not inserted: ordered (by default), the ones after it are not either; unordered (ordered: false),
+     * they are. The documents not inserted fail the insertMany (EmbeddedBulkWriteError) once the others are written.
+     *
+     * @param documents
+     * @param options
+     */
+    insertMany(documents: EmbeddedDocument[], options?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        insertedCount: number;
+        insertedIds: {
+            [index: number]: any;
+        };
+    }>;
+    updateOne(query: EmbeddedDocument, update: EmbeddedDocument, options?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedCount: number;
+        upsertedId: any;
+    }>;
+    updateMany(query: EmbeddedDocument, update: EmbeddedDocument, options?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedCount: number;
+        upsertedId: any;
+    }>;
+    replaceOne(query: EmbeddedDocument, replacement: EmbeddedDocument, options?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedCount: number;
+        upsertedId: any;
+    }>;
+    deleteOne(query?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    deleteMany(query?: EmbeddedDocument): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    createIndex(keys: any, options?: EmbeddedDocument): Promise<string>;
+    createIndexes(specs: EmbeddedDocument[]): Promise<string[]>;
+    indexes(): Promise<EmbeddedDocument[]>;
+    listIndexes(): EmbeddedArrayCursor;
+    indexExists(names: string | string[]): Promise<boolean>;
+    indexInformation(): Promise<EmbeddedDocument>;
+    dropIndex(name: string): Promise<EmbeddedDocument>;
+    dropIndexes(): Promise<boolean>;
+    isCapped(): Promise<boolean>;
+    bulkWrite(): Promise<never>;
+    findOneAndDelete(): Promise<never>;
+    findOneAndReplace(): Promise<never>;
+    findOneAndUpdate(): Promise<never>;
+    initializeOrderedBulkOp(): never;
+    initializeUnorderedBulkOp(): never;
+    rename(): Promise<never>;
+    watch(): never;
+    /**
+     * The store of the collection, created when a document is inserted in it (an upsert too) or an index created, as
+     * MongoDB creates it.
+     *
+     * @param create
+     */
+    protected collection(create?: boolean): EmbeddedCollectionStore | undefined;
+    /**
+     * The documents a filter may match, in batches, the event loop yielded between them: the ones of its _id or of the
+     * ranges of an index when the planner gives them, else all of them by a scan of the files of the collection.
+     *
+     * @param filter
+     */
+    protected candidates(filter: EmbeddedDocument): AsyncGenerator<EmbeddedDocument[]>;
+    /**
+     * The documents matching a filter in the order of a sort of one field, up to a number, read in the order of an
+     * index of the field (from its range in the filter, if any; all of it when the filter gives several ranges);
+     * undefined when no index gives that order, when the filter is planned on the _id or on another index, or when the
+     * walk meets a value it does not order as MongoDB sorts it (the documents then sorted in memory). The walk is
+     * synchronous (the index is not changed meanwhile).
+     *
+     * @param query
+     * @param sort
+     * @param count
+     */
+    ordered(query: EmbeddedDocument, sort: EmbeddedDocument, count: number): EmbeddedDocument[] | undefined;
+    /**
+     * A document found by a write, read again: undefined when it is not held or does not match any more.
+     *
+     * @param collection
+     * @param matches the test of the filter of the write
+     * @param found
+     */
+    protected current(collection: EmbeddedCollectionStore, matches: (document: EmbeddedDocument) => boolean, found: EmbeddedDocument): EmbeddedDocument | undefined;
+    /**
+     * The test of a filter, compiled by mingo once (when a document needs it): a filter of the _id alone is not
+     * compiled for the documents of which the _id is its value.
+     *
+     * @param filter
+     */
+    protected matcherOf(filter: EmbeddedDocument): (document: EmbeddedDocument) => boolean;
+    /**
+     * The value of a filter of the _id alone, when it is a string, a number or an ObjectId (the documents it matches
+     * are the one of the key of that value); undefined for the other filters.
+     *
+     * @param filter
+     */
+    protected idOf(filter: EmbeddedDocument): any;
+    /**
+     * Whether the _id of a document is the value of a filter of the _id alone itself (the filter matches it then):
+     * the same string or number, or an ObjectId of the same bytes.
+     *
+     * @param documentId
+     * @param id the value of the filter, given by idOf()
+     */
+    protected isId(documentId: any, id: any): boolean;
+    /**
+     * Inserts documents, their _id added when missing (also to the documents given, as MongoDB does); the documents
+     * stored.
+     *
+     * @param documents
+     */
+    protected insert(documents: EmbeddedDocument[]): Promise<EmbeddedDocument[]>;
+    /**
+     * The number of the documents a filter matches, counted without reading them when its plan is exact.
+     *
+     * @param filter
+     */
+    protected exactCount(filter: EmbeddedDocument): number | undefined;
+    protected isPlainObject(value: any): boolean;
+    /**
+     * Whether a stage of a pipeline is a $match of a filter, and nothing else.
+     *
+     * @param stage
+     */
+    protected isMatchStage(stage: any): boolean;
+    /**
+     * The fields a filter sets by equality, for the document of an upsert.
+     *
+     * @param filter
+     */
+    protected equalities(filter: EmbeddedDocument): EmbeddedDocument;
+    /**
+     * Updates the documents a filter matches (the first one, unless many): read in batches, each batch of documents
+     * read again, updated by mingo together and written as one operation, the event loop yielded between them. A
+     * batch failing (an update failing on a document, a duplicate key) is written a document at a time up to the one
+     * failing, as MongoDB writes the documents in their order.
+     *
+     * @param query
+     * @param update
+     * @param options
+     * @param many
+     */
+    protected update(query: EmbeddedDocument, update: EmbeddedDocument, options: EmbeddedDocument | undefined, many: boolean): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedCount: number;
+        upsertedId: any;
+    }>;
+    /**
+     * The changes of documents updated together by mingo (once for all of them): the documents of which the BSON
+     * changed.
+     *
+     * @param documents
+     * @param modifier
+     * @param arrayFilters
+     */
+    protected updateChanges(documents: EmbeddedDocument[], modifier: EmbeddedDocument, arrayFilters: EmbeddedDocument[] | undefined): EmbeddedChange[];
+    /**
+     * Writes the changes of documents as one operation (at once, before it awaits); when they fail, whatever the error
+     * (of mingo, a changed _id, a key), a document at a time up to the one failing, as MongoDB writes them in order:
+     * the error thrown once the ones written before it are written as the option sync tells; the number of the changes
+     * written.
+     *
+     * @param collection
+     * @param documents
+     * @param changesOf the changes of documents
+     */
+    protected writeInOrder(collection: EmbeddedCollectionStore, documents: EmbeddedDocument[], changesOf: (documents: EmbeddedDocument[]) => EmbeddedChange[]): Promise<number>;
+    /**
+     * Writes the insertions of a batch of documents as one operation; when a key of them is a duplicate or too large, a
+     * document at a time, the ones failing told (and, ordered, the ones after the first one failing not written); the
+     * indexes in the batch of the documents written. The errors of the documents are thrown before their write is
+     * written; the other errors (of the file) end the insertMany.
+     *
+     * @param collection
+     * @param batch
+     * @param ordered
+     * @param writeErrors the errors of the documents failing
+     * @param start the index of the batch in the documents of the insertMany
+     */
+    protected writeInsertions(collection: EmbeddedCollectionStore, batch: EmbeddedDocument[], ordered: boolean, writeErrors: EmbeddedWriteError[], start: number): number[];
+    /**
+     * After a batch of a write: resolved once it is written as the option sync tells (with the batches before it),
+     * awaited by the write once its batches are written (its failure handled meanwhile).
+     *
+     * @param collection
+     */
+    protected synced(collection: EmbeddedCollectionStore): Promise<void>;
+    /**
+     * Deletes the documents a filter matches (the first one, unless many): read in batches, each batch of documents
+     * read again and deleted as one operation, the event loop yielded between them.
+     *
+     * @param query
+     * @param many
+     */
+    protected delete(query: EmbeddedDocument | undefined, many: boolean): Promise<{
+        acknowledged: boolean;
+        deletedCount: number;
+    }>;
+    protected updateResult(matched: number, modified: number, upsertedId?: any): {
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedCount: number;
+        upsertedId: any;
+    };
+    protected immutableId(): TypeORMError;
+}
+/**
+ * lakutata: the database of an embedded client (it has one, whatever its name).
+ */
+export declare class EmbeddedDb {
+    readonly databaseName: string;
+    protected readonly store: EmbeddedStore;
+    protected readonly collections: Map<string, EmbeddedCollection>;
+    constructor(databaseName: string, store: EmbeddedStore);
+    collection(name: string): EmbeddedCollection;
+    dropDatabase(): Promise<boolean>;
+    dropCollection(name: string): Promise<boolean>;
+}
+/**
+ * lakutata: the client of an embedded MongoDB, with the API of the client of MongoDB that TypeORM calls: its
+ * collections in the files of a directory (or in memory), queried and updated by mingo.
+ */
+export declare class EmbeddedClient {
+    readonly store: EmbeddedStore;
+    protected database?: EmbeddedDb;
+    constructor(store: EmbeddedStore);
+    /**
+     * Opens a database: its directory locked, the files of its collections read.
+     *
+     * @param directory the directory of the database, or ":memory:"
+     * @param options
+     * @param mingo
+     * @param bson
+     */
+    static connect(directory: string | undefined, options: EmbeddedStoreOptions, mingo: any, bson: any, token?: string): Promise<EmbeddedClient>;
+    db(name?: string): EmbeddedDb;
+    close(): Promise<void>;
+}
+export {};