@nextage/nx-frame-be 1.0.1

package/build/common/base/base.model.d.ts

@@ -0,0 +1,384 @@
+/// <reference types="node" />
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+/// <reference types="mongoose/types/inferrawdoctype" />
+import mongoose from 'mongoose';
+import { EventEmitter } from 'events';
+import { NxContext, NxObject } from '../interfaces';
+import { BaseMongoDoc, BaseMongoModel } from './base.interfaces';
+import { ArrayItemParams, ChangeStreamData } from './base.interfaces';
+import { CrudItemEvent, FilterParams } from './base.interfaces';
+import { QueryPagination } from './base.interfaces';
+import { ModelData, ModelDefParams } from './mongo.types';
+export declare class BaseModel<TAttrs, TDoc extends BaseMongoDoc, TMongoModel extends BaseMongoModel<TAttrs, TDoc>> extends EventEmitter {
+    name: string;
+    mgModel: TMongoModel;
+    private readonly defaultParams;
+    private readonly logger;
+    private readonly events;
+    constructor({ name, model, params, logger }: ModelData<TDoc, TMongoModel>);
+    /**
+     *
+     */
+    get schema(): {
+        id?: mongoose.SchemaDefinitionProperty<string | undefined, BaseMongoDoc> | undefined;
+        _id?: mongoose.SchemaDefinitionProperty<unknown, BaseMongoDoc> | undefined;
+        __v?: mongoose.SchemaDefinitionProperty<any, BaseMongoDoc> | undefined;
+    };
+    /**
+     * Get mongodb collection name
+     */
+    get collectionName(): string | null;
+    /**
+     * Get Mongoose model name
+     */
+    get modelName(): string | null;
+    /**
+     * Get default parameters
+     */
+    get modelParams(): ModelDefParams | null;
+    /**
+     *
+     */
+    init(): void;
+    /**
+     *
+     * @param {*} options
+     */
+    initBulk(options?: mongoose.mongo.BulkWriteOptions): mongoose.mongo.OrderedBulkOperation;
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregate(pipeline: mongoose.PipelineStage[], params?: FilterParams, context?: NxContext): Promise<any[]>;
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregateNativeFiltered(pipeline: mongoose.PipelineStage[], params: FilterParams | undefined, context: NxContext): Promise<mongoose.mongo.AggregationCursor<any> | null>;
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregateNative(pipeline: mongoose.PipelineStage[]): mongoose.mongo.AggregationCursor<any>;
+    /**
+     * Simple Find wrapper
+     * @param {*} params
+     * @param {*} fields
+     * @param {*} options
+     */
+    find(params: FilterParams, fields: NxObject, options: mongoose.QueryOptions<TDoc>): Promise<(mongoose.Document<unknown, {}, BaseMongoDoc> & BaseMongoDoc & Required<{
+        _id: unknown;
+    }>)[]>;
+    list(params?: FilterParams, fields?: mongoose.ProjectionType<BaseMongoDoc>, pagination?: QueryPagination, context?: NxContext): Promise<TDoc[]>;
+    list(params: FilterParams, fields: mongoose.ProjectionType<BaseMongoDoc>, pagination: QueryPagination, queryActions: NxObject, context: NxContext): Promise<TDoc[]>;
+    /**
+     * Get documents using mongodb native method
+     *
+     * @param {*} params
+     * @param {*} callback
+     */
+    listNative(params?: FilterParams, options?: mongoose.mongo.FindOptions<mongoose.mongo.BSON.Document>): mongoose.mongo.FindCursor<mongoose.mongo.WithId<mongoose.mongo.BSON.Document>>;
+    /**
+     *
+     * @param params
+     * @param context
+     * @returns
+     */
+    count(params?: FilterParams, context?: NxContext): Promise<number>;
+    /**
+     * Get document by ID using Moongose wrapper method
+     *
+     * @param {*} id
+     * @param context
+     */
+    get(id: string, context?: NxContext): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} item
+     * @param {*} context
+     */
+    checkContextPermission(item: any, context?: NxContext): any;
+    /**
+     *
+     * @param {*} context
+     */
+    checkChannelSubscriber(payloadId: string, context?: NxContext): Promise<boolean>;
+    /**
+     * Get document using Moongose wrapper method
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    findOne(params: FilterParams, context?: NxContext): Promise<TDoc | null>;
+    /**
+     * Get document and update using Moongose wrapper method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    findOneAndUpdate(filter: FilterParams, update: mongoose.UpdateQuery<TDoc>, options: NxObject): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} params
+     */
+    findOneNative(params: FilterParams): Promise<mongoose.mongo.WithId<mongoose.mongo.BSON.Document> | null>;
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCreate(item: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} item
+     */
+    beforeUpdate(item: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCopy(item: TAttrs, context: NxContext): Promise<TAttrs>;
+    /**
+     *
+     * @param {*} id
+     */
+    beforeRemove(id: string, context: NxContext): Promise<string>;
+    /**
+     *
+     * @param {*} item
+     */
+    afterCreate(item: TDoc, context: NxContext): Promise<TDoc>;
+    /**
+     *
+     * @param {*} item
+     */
+    afterUpdate(item: TDoc, context: NxContext): Promise<TDoc>;
+    /**
+     *
+     * @param {*} item
+     */
+    afterCopy(item: TDoc, context: NxContext): Promise<TDoc>;
+    /**
+     *
+     * @param {*} item
+     */
+    afterRemove(item: TDoc, context: NxContext): Promise<TDoc>;
+    /**
+     *
+     * @param {*} params
+     */
+    manageFilterArrayParams(params: FilterParams): void;
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    updateFilters(params: FilterParams, context: NxContext): Promise<FilterParams | null>;
+    /**
+     *
+     * @param {*} sort
+     */
+    parseSortObject(sort: NxObject): NxObject;
+    /**
+     * Create document using Moongose wrapper method
+     *
+     * @param {*} item
+     */
+    create(item: TAttrs, context: NxContext): Promise<TDoc>;
+    /**
+     * Call insertOne mongodb native method
+     *
+     * @param {*} items
+     * @param {*} callback
+     */
+    insertOneNative(item: TAttrs, context: NxContext): Promise<mongoose.mongo.InsertOneResult<mongoose.mongo.BSON.Document>>;
+    /**
+     * Call insertMany Mongoose method
+     *
+     * @param {*} items
+     * @param {*} options
+     */
+    insertMany(items: TDoc, options: mongoose.InsertManyOptions): Promise<NxObject[]>;
+    /**
+     * Call insertMany mongodb native method
+     *
+     * @param {*} items
+     * @param {*} callback
+     */
+    insertManyNative(items: mongoose.mongo.OptionalId<Document>[], options: mongoose.mongo.BulkWriteOptions): Promise<mongoose.mongo.InsertManyResult<mongoose.mongo.BSON.Document>>;
+    update(id: string, item: TAttrs, context: NxContext): Promise<TDoc>;
+    update(id: string, item: TAttrs, mergeItem: boolean, context: NxContext): Promise<TDoc>;
+    /**
+     * Update document using mongodb generic method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    updateOne(filter: FilterParams, update: mongoose.UpdateQuery<TMongoModel>, options?: mongoose.QueryOptions<TMongoModel>): Promise<TMongoModel | null>;
+    /**
+     * Update document using mongodb native method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     * @param {*} callback
+     */
+    updateNative(filter: FilterParams, update: mongoose.UpdateQuery<TMongoModel>, options?: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     * Update many documents using mongodb native method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    updateManyNative(filter: FilterParams, update: mongoose.UpdateQuery<TMongoModel>, options?: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     * Update document using Mongoose wrapper method
+     *
+     * @param {*} id
+     * @param {*} update
+     * @param {*} options
+     */
+    updateRaw(id: string, update: mongoose.UpdateQuery<TMongoModel>, options?: mongoose.QueryOptions<TMongoModel>): Promise<TMongoModel | null>;
+    /**
+     * Copy document by ID
+     *
+     * @param {*} id
+     */
+    copy(id: string, item: TAttrs, context: NxContext): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    addArrayItem(id: string, { arrayPath, item }: ArrayItemParams, options: mongoose.QueryOptions<Document> | undefined, context: NxContext): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     * @param {*} callback
+     */
+    addArrayItemNative(id: string, { arrayPath, item }: ArrayItemParams, options: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} updateParams
+     * @param {*} options
+     */
+    updateArrayItem(id: string, { arrayPath, arrayFilter, updateAttr, partial, item }: ArrayItemParams, options: mongoose.QueryOptions<Document> | undefined, context: NxContext): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} updateParams
+     * @param {*} options
+     */
+    updateArrayItemNative(id: string, { arrayPath, arrayFilter, updateAttr, item }: ArrayItemParams, options: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+   *
+   * @param {*} id
+   * @param {*} updateParams
+   * @param {*} options
+   */
+    updateArrayItemManyNative(filter: NxObject, { arrayPath, arrayFilter, updateAttr, item }: ArrayItemParams, options: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    removeArrayItem(id: string, { arrayPath, item }: ArrayItemParams, options: mongoose.QueryOptions<Document> | undefined, context: NxContext): Promise<TDoc | null>;
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    removeArrayItemNative(id: string, { arrayPath, item }: ArrayItemParams, options: mongoose.mongo.UpdateOptions): Promise<mongoose.mongo.UpdateResult<Document>>;
+    /**
+     * Delete document using Mongoose wrapper method
+     *
+     * @param {*} id
+     */
+    remove(id: string, context: NxContext): Promise<TDoc>;
+    /**
+     *
+     * @param {*} filter
+     * @param {*} callback
+     */
+    removeNative(filter: FilterParams, options?: mongoose.mongo.DeleteOptions): Promise<mongoose.mongo.DeleteResult>;
+    /**
+     *
+     * @param items
+     * @param context
+     * @returns
+     */
+    bulkCreate(items: TAttrs[], context: NxContext): Promise<(Awaited<TDoc> | null)[]>;
+    /**
+     *
+     * @param ids
+     * @param items
+     * @param context
+     * @returns
+     */
+    bulkUpdate(ids: string[], items: TAttrs | TAttrs[], context: NxContext): Promise<(Awaited<TDoc> | null)[]>;
+    /**
+     *
+     * @param ids
+     * @param context
+     * @returns
+     */
+    bulkRemove(ids: string, context: NxContext): Promise<TDoc[]>;
+    /**
+     *
+     * @param {*} evt
+     * @param {*} context
+     */
+    publishCRUDEvent(evt: CrudItemEvent, context?: NxContext): void;
+    /**
+     *
+     * @param {*} name Name of new stream to be created
+     * @param {*} pipeline Filter pipeline
+     * @param {*} callback stream event callback
+     * @param {*} duration time in ms to terminate the stream
+     * @returns change stream data { name, duration, stream }
+     */
+    addChangeStream(name: string, pipeline?: Record<string, unknown>[], callback?: Function, duration?: number): Promise<ChangeStreamData>;
+    /**
+     *
+     * @param {*} csData change stream data { name, duration, stream }
+     * @returns
+     */
+    closeChangeStream({ name, stream, duration }: ChangeStreamData): Promise<void>;
+}