@onesy/mongo/BaseCollection.d.ts

Utils for easier using of mongodb library.

import * as mongodb from 'mongodb';
import express from 'express';
import { TMethod, IMongoResponse, IMongoSearchAdditional, IClass } from '@onesy/models';
import OnesyLog from '@onesy/log';
import Mongo from './Mongo';
export type IMongoLookup = {
    property?: string;
    query?: any;
    projection?: any;
    override?: string[];
    options?: mongodb.AggregateOptions;
    objects: BaseCollection<any>;
    toObjectResponse?: boolean;
};
export type IMongoOption = {
    name: string;
    property: string;
    version?: 'array' | 'object' | 'string' | 'objectID';
    lookup?: IMongoLookup;
};
export interface IMongoSearchManyAdditional extends IMongoSearchAdditional {
    lookups?: IMongoLookup[];
    options?: IMongoOption[];
}
export interface IMongoSearchOneAdditional extends IMongoSearchAdditional {
    lookups?: IMongoLookup[];
}
export interface IUpdateFilters extends mongodb.UpdateFilter<unknown> {
    [p: string]: any;
}
export interface IUpdateOrAddOptions extends mongodb.FindOneAndUpdateOptions {
    add_date?: boolean;
    update_date?: boolean;
    request?: any;
}
export interface IUpdateOptions extends mongodb.FindOneAndUpdateOptions {
    lookups?: IMongoLookup[];
    update_date?: boolean;
    request?: any;
}
export interface IUpdateManyOptions extends mongodb.UpdateOptions {
    update_date?: boolean;
    request?: any;
}
export interface IAddOneOptions extends mongodb.InsertOneOptions {
    add_date?: boolean;
    request?: any;
}
export interface IAddManyOptions extends mongodb.BulkWriteOptions {
    original?: boolean;
    add_date?: boolean;
    request?: any;
}
export interface IFindOptions extends mongodb.FindOptions {
    total?: boolean;
    sort?: any;
    projection?: any;
    request?: any;
}
export interface ISearchOne extends mongodb.AggregateOptions {
    projection?: any;
    request?: any;
}
export interface ISearchManyOptions extends mongodb.AggregateOptions {
    total?: boolean;
    limit?: number;
    skip?: number;
    sort?: any;
    next?: any;
    previous?: any;
    projection?: any;
    request?: any;
}
export interface IAggregateOptions extends mongodb.AggregateOptions {
    request?: any;
}
export interface IRemoveOneOptions extends mongodb.FindOneAndDeleteOptions {
    request?: any;
}
export interface IRemoveManyOptions extends mongodb.DeleteOptions {
    request?: any;
}
export type TMethods = 'count' | 'exists' | 'find' | 'findOne' | 'aggregate' | 'searchMany' | 'searchOne' | 'addOne' | 'updateOne' | 'removeOne' | 'updateOneOrAdd' | 'addMany' | 'updateMany' | 'removeMany' | 'bulkWrite';
export type TDefaultProperties = 'query' | 'queryObject' | 'queryArray';
export type TDefaults = {
    [p in TDefaultProperties | TMethods]: any;
};
export declare class BaseCollection<IModel = any> {
    protected collectionName: string;
    mongo: Mongo;
    Model?: IClass;
    defaults?: TDefaults;
    protected collections: Record<string, mongodb.Collection>;
    protected onesyLog: OnesyLog;
    static defaults: TDefaults;
    constructor(collectionName: string, mongo: Mongo, Model?: IClass, defaults?: TDefaults);
    get sort(): Record<string, number>;
    get sortProperty(): string;
    get sortAscending(): number;
    get addedProperty(): string;
    get updatedProperty(): string;
    get projection(): object;
    get db(): Promise<mongodb.Db>;
    collection(name?: string, options?: mongodb.CreateCollectionOptions): Promise<mongodb.Collection>;
    transaction(method: TMethod, options?: {
        retries: number;
        retriesWait: number;
    }): Promise<any>;
    count(query?: any, options?: mongodb.CountDocumentsOptions): Promise<number>;
    exists(query: any, options?: mongodb.FindOptions): Promise<boolean>;
    find(query: any, options?: IFindOptions): Promise<IMongoResponse>;
    findOne(query: any, options?: mongodb.FindOptions): Promise<IModel>;
    aggregate(query?: any, options?: IAggregateOptions): Promise<Array<IModel>>;
    searchMany(query: any, additional?: IMongoSearchManyAdditional, options?: ISearchManyOptions): Promise<IMongoResponse>;
    searchOne(query: any, additional?: IMongoSearchOneAdditional, options?: ISearchOne): Promise<IModel>;
    addOne(value_: any, options_?: IAddOneOptions): Promise<IModel>;
    updateOne(query: any, value: IUpdateFilters, options_?: IUpdateOptions): Promise<IModel>;
    removeOne(query: any, options?: IRemoveOneOptions): Promise<mongodb.ModifyResult<IModel>>;
    updateOneOrAdd(query: any, value: any, options_?: IUpdateOrAddOptions): Promise<IModel>;
    addMany(values_: any[], options_?: IAddManyOptions): Promise<Array<IModel>>;
    updateMany(query: any, value: IUpdateFilters, options_?: IUpdateManyOptions): Promise<number>;
    removeMany(query: any, options?: IRemoveManyOptions): Promise<number>;
    bulkWrite(values?: mongodb.AnyBulkWriteOperation[], options_?: mongodb.BulkWriteOptions): Promise<mongodb.BulkWriteResult>;
    lookups(value_: any, lookups: IMongoLookup[], request: any): Promise<void>;
    updateLookupProperty(mongoObject: any, object: any, responseMap: any, lookup: IMongoLookup, array?: boolean): any;
    getLookupIDs(value: any): any[];
    protected toModel(value: any): any;
    protected response(start: number, collection: mongodb.Collection, method: string, value?: any, req?: express.Request): any;
    query(query: any, aggregate?: boolean): any;
    getDefaults(method: TMethods): void;
    static value(value: any): any;
    static isOnesyQuery(value: any): any;
}
export default BaseCollection;