flexiblepersistence/dist/source/database/noSQL/mongoDB/mongoPersistence.d.ts

A CQRS and Event Sourcing platform

import { Schema, Mongoose, QueryOptions, Document, InsertManyResult, PipelineStage, PopulateOptions, ClientSessionOptions } from 'mongoose';
import { IPersistence } from '../../../iPersistence/iPersistence';
import { PersistenceInfo } from '../../persistenceInfo';
import { IOutput } from '../../../iPersistence/output/iOutput';
import { Event } from '../../../event/event';
import { IInputUpdate, IInputDelete, IInputCreate, IInputRead, IInput } from '../../..';
import BaseSchemaDefault from './baseSchemaDefault';
import { IOptions } from '../../../event/iOptions';
import { CastType } from './toCast';
import { FullOperation } from '../../../event/fullOperation';
import { TransactionOptions } from 'mongodb';
import { PipelineCRUD, PipelineCRUDType } from './pipelineCRUD';
import { AnyModel } from './anyModel';
import { ITransaction } from '../../../iPersistence/iTransaction';
import { Transaction } from './transaction';
export declare class MongoPersistence implements IPersistence {
    protected persistenceInfo: PersistenceInfo;
    protected mongooseInstance: Mongoose;
    element: {
        [name: string]: BaseSchemaDefault;
    };
    constructor(persistenceInfo: PersistenceInfo, element?: {
        [name: string]: BaseSchemaDefault;
    });
    transaction(options: {
        session?: ClientSessionOptions;
        transaction?: TransactionOptions;
    }, callback: (transaction: Transaction) => Promise<void>): Promise<ITransaction>;
    protected initElement(): void;
    setElement(element?: {
        [name: string]: BaseSchemaDefault;
    }): void;
    getModel(name: string): AnyModel;
    getModels(): {
        [index: string]: AnyModel;
    };
    addModel(name: string, schema: Schema): AnyModel;
    protected populateStep(query: any, populateOptions: (string | PopulateOptions)[] | string | PopulateOptions, populate: any, callback: any): any;
    protected getCrud(method: string): PipelineCRUDType;
    protected isPipelineCrud(pipeline: PipelineStage | PipelineStage[] | PipelineCRUD | undefined): boolean;
    protected populate(scheme: string, method: string, queryParams: unknown[], populateOptions: (string | PopulateOptions)[] | string | PopulateOptions, callback?: any): any;
    protected populateAll(scheme: string, method: string, //query (model[method].bind(model)) => model.create.bind(model)
    queryParams?: unknown[], fullOperation?: FullOperation, callback?: (..._params: any[]) => void): any;
    protected execute(query: any, queryParams: any, callback?: any): any;
    protected advancedFilter(queryParams?: any[]): void;
    protected filterQueryParams(queryParams?: unknown[]): unknown[];
    protected toCast(type: CastType): string;
    protected toCastAll(schema: string, fullOperation?: FullOperation): string;
    protected clearModel(scheme: string): Promise<boolean>;
    clear(): Promise<boolean>;
    other(input: IInput<unknown, Event>): Promise<IOutput<unknown, unknown, unknown>>;
    create(input: IInputCreate<Event, Event>): Promise<IOutput<Event, Event, unknown>>;
    read(input: IInputRead<Event>): Promise<IOutput<Event, unknown, unknown>>;
    update(input: IInputUpdate<Event, Event>): Promise<IOutput<Event, Event, unknown>>;
    delete(input: IInputDelete<Event>): Promise<IOutput<Event, unknown, unknown>>;
    protected cleanReceived(received: {
        receivedItem?: any;
        result?: any;
        selectedItem?: any;
        sentItem?: any;
    }): {
        receivedItem?: any;
        result?: any;
        selectedItem?: any;
        sentItem?: any;
    };
    generateOptions(options?: QueryOptions, eventOptions?: IOptions): QueryOptions<unknown> | {
        limit: number | undefined;
        skip: number | undefined;
        sort: any;
        perDocumentLimit: any;
        _recursed: any;
        tailable: any;
        allowDiskUse: any;
        batchSize: any;
        readPreference: any;
        hint: any;
        comment: any;
        snapshot: any;
        maxscan: any;
        upsert: any;
        writeConcern: any;
        timestamps: any;
        overwriteDiscriminatorKey: any;
        lean: any;
        populate: any;
        projection: any;
        sanitizeProjection: any;
        maxTimeMS: any;
        rawResult: any;
        strict: any;
        collation: any;
        session: any;
        explain: any;
        arrayFilters?: {
            [key: string]: any;
        }[] | undefined;
        context?: string | undefined;
        fields?: any;
        multi?: boolean | undefined;
        multipleCastError?: boolean | undefined;
        new?: boolean | undefined;
        overwrite?: boolean | undefined;
        returnOriginal?: boolean | undefined;
        returnDocument?: "before" | "after" | undefined;
        runValidators?: boolean | undefined;
        sanitizeFilter?: boolean | undefined;
        setDefaultsOnInsert?: boolean | undefined;
        strictQuery?: boolean | "throw" | undefined;
    } | undefined;
    count(scheme: string, selectedItem: Event, options?: QueryOptions, eventOptions?: IOptions, compiledOptions?: QueryOptions): Promise<void>;
    protected generateReceivedArray(docs: Document[] | Document | InsertManyResult<unknown> | undefined | null, scheme?: string, fullOperation?: FullOperation): unknown[];
    protected generateNewArray(item?: Event | Event[], regular?: boolean): Event | Event[];
    protected generateNewItem(item?: Event | {
        id?: unknown;
    }): Event;
    protected generateReceivedItem(doc: Document<unknown, unknown, unknown> | InsertManyResult<unknown> | undefined | null, scheme?: string, fullOperation?: FullOperation): unknown;
    createItem(scheme: string, item: Event): Promise<IOutput<Event, Event, unknown>>;
    createArray(scheme: string, item?: Event | Event[], regular?: boolean, options?: QueryOptions): Promise<IOutput<Event, Event, unknown>>;
    readArray(scheme: string, selectedItem?: Event, options?: QueryOptions, additionalOptions?: unknown, eventOptions?: IOptions): Promise<IOutput<Event, unknown, unknown>>;
    readItem(scheme: string, selectedItem?: Event, options?: QueryOptions, additionalOptions?: unknown, eventOptions?: IOptions): Promise<IOutput<Event, unknown, unknown>>;
    readItemById(scheme: string, id: unknown, options?: QueryOptions, additionalOptions?: unknown, eventOptions?: IOptions): Promise<IOutput<Event, unknown, unknown>>;
    updateItem(scheme: string, selectedItem?: Event, item?: Event, options?: QueryOptions): Promise<IOutput<Event, Event, unknown>>;
    updateArray(scheme: string, selectedItem?: Event, item?: Event | Event[], regular?: boolean, options?: QueryOptions): Promise<IOutput<Event, Event, unknown>>;
    deleteArray(scheme: string, selectedItem?: Event, options?: QueryOptions): Promise<IOutput<Event, unknown, unknown>>;
    deleteItem(scheme: string, selectedItem?: Event, options?: QueryOptions): Promise<IOutput<Event, unknown, unknown>>;
    deleteItemById(scheme: string, id: unknown, options?: QueryOptions): Promise<IOutput<Event, unknown, unknown>>;
    findOneAndUpdateResult(resolve: (_value?: any) => void, reject: (_reason?: any) => void, error: unknown, doc: Document, result: unknown, scheme?: string, fullOperation?: FullOperation): Promise<void>;
    findOneAndUpdate(scheme: string, selectedItem: Event, item: Event, options?: QueryOptions): Promise<{
        receivedItem: unknown;
        result: unknown;
    }>;
    getPersistenceInfo(): PersistenceInfo;
    close(): Promise<boolean>;
}
//# sourceMappingURL=mongoPersistence.d.ts.map