@nextage/nx-frame-be 1.0.1

package/build/common/base/base.model.js

@@ -0,0 +1,730 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseModel = void 0;
+const events_1 = require("events");
+const utils_1 = require("../utils");
+const constants_1 = require("../constants");
+const enums_1 = require("../enums");
+const errors_1 = require("../errors");
+const mongo_utils_1 = require("./mongo-utils");
+class BaseModel extends events_1.EventEmitter {
+    constructor({ name, model, params, logger }) {
+        super();
+        this.defaultParams = {};
+        this.logger = constants_1.APP.logger;
+        this.defaultParams = params || {};
+        this.name = name || 'Base';
+        this.mgModel = model;
+        this.logger = logger || constants_1.APP.logger;
+        this.events = {};
+        this.init();
+    }
+    /**
+     *
+     */
+    get schema() {
+        return this.mgModel.schema.obj;
+    }
+    /**
+     * Get mongodb collection name
+     */
+    get collectionName() {
+        if (!this.mgModel)
+            return null;
+        return this.mgModel.collection.collectionName;
+    }
+    /**
+     * Get Mongoose model name
+     */
+    get modelName() {
+        if (!this.mgModel)
+            return null;
+        return this.mgModel.modelName;
+    }
+    /**
+     * Get default parameters
+     */
+    get modelParams() {
+        if (!this.defaultParams)
+            return null;
+        return this.defaultParams;
+    }
+    /**
+     *
+     */
+    init() {
+    }
+    /**
+     *
+     * @param {*} options
+     */
+    initBulk(options) {
+        return this.mgModel.collection.initializeOrderedBulkOp(options);
+    }
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregate(pipeline_1) {
+        return __awaiter(this, arguments, void 0, function* (pipeline, params = {}, context = {}) {
+            try {
+                const filter = yield this.updateFilters(params, context);
+                if (!filter)
+                    return [];
+                if (Object.keys(filter).length)
+                    pipeline.unshift({ $match: filter });
+                return yield this.mgModel.aggregate(pipeline).allowDiskUse(true);
+            }
+            catch (e) {
+                return [];
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregateNativeFiltered(pipeline_1) {
+        return __awaiter(this, arguments, void 0, function* (pipeline, params = {}, context) {
+            try {
+                const filter = yield this.updateFilters(params, context);
+                if (!filter)
+                    return Promise.resolve(null);
+                if (Object.keys(filter).length)
+                    pipeline.unshift({ $match: filter });
+                return this.mgModel.collection.aggregate(pipeline, { allowDiskUse: true });
+            }
+            catch (e) {
+                return Promise.resolve(null);
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} pipeline
+     * @param {*} params
+     * @param {*} context
+     */
+    aggregateNative(pipeline) {
+        return this.mgModel.collection.aggregate(pipeline, { allowDiskUse: true });
+    }
+    /**
+     * Simple Find wrapper
+     * @param {*} params
+     * @param {*} fields
+     * @param {*} options
+     */
+    find(params, fields, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.mgModel.find(params, fields, options);
+        });
+    }
+    /**
+     * Get documents using Moongose wrapper method
+     *
+     * @param {*} params
+     */
+    list() {
+        return __awaiter(this, arguments, void 0, function* (params = {}, fields = {}, { offset, limit, sort } = {}, p4 = {}, p5) {
+            let context;
+            let queryActions = {};
+            if (p5) {
+                queryActions = p4;
+                context = p5;
+            }
+            else
+                context = p4;
+            const filter = yield this.updateFilters(params, context);
+            if (!filter)
+                return [];
+            let options = {};
+            if (offset || limit)
+                options = { skip: offset, limit: limit };
+            if (sort || this.defaultParams.sort)
+                options.sort = this.parseSortObject(sort || this.defaultParams.sort);
+            // return await this.mgModel.find(filter, fields, options).sort(this.parseSortObject(sort || this.defaultParams.sort!));
+            let query = this.mgModel.find(filter, fields, options);
+            if (Array.isArray(queryActions.populate))
+                queryActions.populate.forEach(ref => query = query.populate(ref));
+            return query;
+        });
+    }
+    /**
+     * Get documents using mongodb native method
+     *
+     * @param {*} params
+     * @param {*} callback
+     */
+    listNative(params = {}, options = {}) {
+        let cursor = this.mgModel.collection.find(params, options);
+        return cursor;
+        //return mongodb.db.collection(this.collectionName).find(params).toArray(callback);
+    }
+    /**
+     *
+     * @param params
+     * @param context
+     * @returns
+     */
+    count() {
+        return __awaiter(this, arguments, void 0, function* (params = {}, context = {}) {
+            const filter = yield this.updateFilters(params, context);
+            if (!filter)
+                return 0;
+            return this.mgModel.countDocuments(filter);
+        });
+    }
+    /**
+     * Get document by ID using Moongose wrapper method
+     *
+     * @param {*} id
+     * @param context
+     */
+    get(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, context = {}) {
+            if (!id)
+                return Promise.resolve(null);
+            return this.mgModel.findById(id);
+        });
+    }
+    /**
+     *
+     * @param {*} item
+     * @param {*} context
+     */
+    checkContextPermission(item, context = {}) {
+        return Promise.resolve((context.user) ? item : null);
+    }
+    /**
+     *
+     * @param {*} context
+     */
+    checkChannelSubscriber(payloadId, context = {}) {
+        return Promise.resolve(!!(context.user));
+    }
+    /**
+     * Get document using Moongose wrapper method
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    findOne(params_1) {
+        return __awaiter(this, arguments, void 0, function* (params, context = {}) {
+            const filter = yield this.updateFilters(params, context);
+            if (!filter)
+                return Promise.resolve(null);
+            return this.mgModel.findOne(filter);
+        });
+    }
+    /**
+     * Get document and update using Moongose wrapper method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    findOneAndUpdate(filter, update, options) {
+        return this.mgModel.findOneAndUpdate(filter, update, options);
+    }
+    /**
+     *
+     * @param {*} params
+     */
+    findOneNative(params) {
+        return this.mgModel.collection.findOne(params);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCreate(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeUpdate(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    beforeCopy(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} id
+     */
+    beforeRemove(id, context) {
+        return Promise.resolve(id);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    afterCreate(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    afterUpdate(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    afterCopy(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} item
+     */
+    afterRemove(item, context) {
+        return Promise.resolve(item);
+    }
+    /**
+     *
+     * @param {*} params
+     */
+    manageFilterArrayParams(params) {
+        for (let k in params) {
+            if (!k.startsWith('$') && Array.isArray(params[k])) {
+                if (k === '_id' || k === 'id')
+                    params[k] = params[k].map((p) => (0, mongo_utils_1.toObjectId)(p));
+                params[k] = { $in: params[k] };
+            }
+        }
+    }
+    /**
+     *
+     * @param {*} params
+     * @param {*} context
+     */
+    updateFilters(params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!params)
+                params = {};
+            this.manageFilterArrayParams(params);
+            (_a = params.rangeDate) !== null && _a !== void 0 ? _a : (params.rangeDate = {});
+            let and = [];
+            if (params.rangeDate.eq) {
+                params.rangeDate.from = params.rangeDate.eq;
+                params.rangeDate.to = params.rangeDate.eq;
+            }
+            if (params.rangeDate.from)
+                and.push({ $or: [{ endDate: { $gte: params.rangeDate.from } }, { endDate: { $exists: false } }] });
+            if (params.rangeDate.to)
+                and.push({ $or: [{ startDate: { $lte: params.rangeDate.to } }, { startDate: { $exists: false } }] });
+            if (and.length)
+                params.$and = and;
+            delete params.rangeDate;
+            if (params.text)
+                params.$text = { $search: params.text };
+            delete params.text;
+            // TMP evaluate if useful
+            // for (let key in params)
+            //   params[key] = parseTypedString(params[key]);
+            return params;
+        });
+    }
+    /**
+     *
+     * @param {*} sort
+     */
+    parseSortObject(sort) {
+        for (let k in sort) {
+            if (sort[k] === 0)
+                sort[k] = -1;
+        }
+        // fix to prevent error of skip limit occurring when results have a lot
+        // of items whith equal order
+        sort._id = 1;
+        return sort;
+    }
+    /**
+     * Create document using Moongose wrapper method
+     *
+     * @param {*} item
+     */
+    create(item, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            item = yield this.beforeCreate(item, context);
+            const itemDoc = this.mgModel.build(item);
+            const res = yield itemDoc.save(); //await this.mgModel.create(item);
+            if (context)
+                context.evtItem = res;
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.create, data: { uid: res.id, model: this.name } }, context);
+            return yield this.afterCreate(res, context);
+        });
+    }
+    /**
+     * Call insertOne mongodb native method
+     *
+     * @param {*} items
+     * @param {*} callback
+     */
+    insertOneNative(item, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            item = yield this.beforeCreate(item, context);
+            return this.mgModel.collection.insertOne(item);
+        });
+    }
+    /**
+     * Call insertMany Mongoose method
+     *
+     * @param {*} items
+     * @param {*} options
+     */
+    insertMany(items, options) {
+        return this.mgModel.insertMany(items, options);
+    }
+    /**
+     * Call insertMany mongodb native method
+     *
+     * @param {*} items
+     * @param {*} callback
+     */
+    insertManyNative(items, options) {
+        return this.mgModel.collection.insertMany(items, options);
+    }
+    /**
+     * Update document by ID using Mongoose wrapper method
+     *
+     * @param {*} id
+     * @param {*} item
+     */
+    update(id, item, param3, param4) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let mergeItem = false;
+            let context = {};
+            if (!param4) {
+                context = param3;
+            }
+            else if (typeof param3 === 'boolean') {
+                mergeItem = param3;
+                context = param4;
+            }
+            item = yield this.beforeUpdate(item, context);
+            //const res = await this.mgModel.findByIdAndUpdate(id, { $set: item }, { new: true });
+            //const itemDoc = this.mgModel.build(Object.assign({ id, item }));
+            const itemDoc = yield this.get(id);
+            if (!itemDoc)
+                throw new errors_1.AppError('messages.notFound');
+            // complete merge
+            if (mergeItem)
+                item = (0, utils_1.merge)(itemDoc.toObject(), item); // Merge with existing doc
+            itemDoc === null || itemDoc === void 0 ? void 0 : itemDoc.set(item);
+            const res = yield itemDoc.save();
+            if (context)
+                context.evtItem = res;
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.update, data: { uid: id, model: this.name } }, context);
+            return yield this.afterUpdate(res, context);
+        });
+    }
+    /**
+     * Update document using mongodb generic method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    updateOne(filter, update, options) {
+        return this.mgModel.findOneAndUpdate(filter, update, options);
+    }
+    /**
+     * Update document using mongodb native method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     * @param {*} callback
+     */
+    updateNative(filter, update, options) {
+        return this.mgModel.collection.updateOne(filter, update, options);
+    }
+    /**
+     * Update many documents using mongodb native method
+     *
+     * @param {*} filter
+     * @param {*} update
+     * @param {*} options
+     */
+    updateManyNative(filter, update, options) {
+        return this.mgModel.collection.updateMany(filter, update, options);
+    }
+    /**
+     * Update document using Mongoose wrapper method
+     *
+     * @param {*} id
+     * @param {*} update
+     * @param {*} options
+     */
+    updateRaw(id, update, options) {
+        return this.mgModel.findByIdAndUpdate(id, update, options || { new: true });
+    }
+    /**
+     * Copy document by ID
+     *
+     * @param {*} id
+     */
+    copy(id, item, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const foundItem = yield this.mgModel.findOne({ _id: (0, mongo_utils_1.toObjectId)(id) });
+            if (!foundItem)
+                return null;
+            const fiAttrs = foundItem.toObject();
+            delete fiAttrs.id;
+            delete fiAttrs._id;
+            item = Object.assign(fiAttrs, item);
+            item = yield this.beforeCopy(item, context);
+            const newItem = this.mgModel.build(item);
+            const res = yield (newItem === null || newItem === void 0 ? void 0 : newItem.save());
+            if (context)
+                context.evtItem = res;
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.create, data: { uid: res === null || res === void 0 ? void 0 : res.id, model: this.name } }, context);
+            return yield this.afterCopy(res, context);
+        });
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    addArrayItem(id_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (id, { arrayPath, item }, options = { new: true }, context) {
+            var _b;
+            let update = { $addToSet: {} };
+            update.$addToSet[arrayPath] = item;
+            (_b = options.new) !== null && _b !== void 0 ? _b : (options.new = true);
+            const res = yield this.mgModel.findByIdAndUpdate(id, update, options);
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.addArrayItem, data: { uid: id, model: this.name, path: arrayPath } }, context);
+            return res;
+        });
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     * @param {*} callback
+     */
+    addArrayItemNative(id, { arrayPath, item }, options) {
+        let filter = { _id: id }, update = { $addToSet: {} };
+        update.$addToSet[arrayPath] = item;
+        return this.mgModel.collection.updateOne(filter, update, options);
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} updateParams
+     * @param {*} options
+     */
+    updateArrayItem(id_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (id, { arrayPath, arrayFilter, updateAttr, partial, item }, options = {}, context) {
+            var _b;
+            let filter = { _id: id }, update = { $set: {} };
+            filter[arrayPath] = { $elemMatch: arrayFilter };
+            if (updateAttr)
+                update.$set[`${arrayPath}.$.${updateAttr}`] = item[updateAttr];
+            else if (partial) {
+                for (let key in item)
+                    update.$set[`${arrayPath}.$.${key}`] = item[key];
+            }
+            else {
+                update.$set[`${arrayPath}.$`] = item;
+            }
+            (_b = options.new) !== null && _b !== void 0 ? _b : (options.new = true);
+            const res = yield this.mgModel.findOneAndUpdate(filter, update, options);
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.updateArrayItem, data: { uid: id, model: this.name, path: arrayPath } }, context);
+            return res;
+        });
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} updateParams
+     * @param {*} options
+     */
+    updateArrayItemNative(id, { arrayPath, arrayFilter, updateAttr, item }, options) {
+        let filter = { _id: id }, update = { $set: {} };
+        filter[arrayPath] = { $elemMatch: arrayFilter };
+        if (updateAttr)
+            update.$set[`${arrayPath}.$.${updateAttr}`] = item[updateAttr];
+        else
+            update.$set[`${arrayPath}.$`] = item;
+        return this.mgModel.collection.updateOne(filter, update, options);
+    }
+    /**
+   *
+   * @param {*} id
+   * @param {*} updateParams
+   * @param {*} options
+   */
+    updateArrayItemManyNative(filter, { arrayPath, arrayFilter, updateAttr, item }, options) {
+        let update = { $set: {} };
+        filter[arrayPath] = { $elemMatch: arrayFilter };
+        if (updateAttr)
+            update.$set[`${arrayPath}.$.${updateAttr}`] = item[updateAttr];
+        else
+            update.$set[`${arrayPath}.$`] = item;
+        return this.mgModel.collection.updateMany(filter, update, options);
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    removeArrayItem(id_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (id, { arrayPath, item }, options = { new: true }, context) {
+            var _b;
+            let update = { $pull: {} };
+            update.$pull[arrayPath] = item;
+            (_b = options.new) !== null && _b !== void 0 ? _b : (options.new = true);
+            const res = yield this.mgModel.findByIdAndUpdate(id, update, options);
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.removeArrayItem, data: { uid: id, model: this.name, path: arrayPath } }, context);
+            return res;
+        });
+    }
+    /**
+     *
+     * @param {*} id
+     * @param {*} param1
+     * @param {*} options
+     */
+    removeArrayItemNative(id, { arrayPath, item }, options) {
+        let filter = { _id: id }, update = { $pull: {} };
+        update.$pull[arrayPath] = item;
+        return this.mgModel.collection.updateOne(filter, update, options);
+    }
+    /**
+     * Delete document using Mongoose wrapper method
+     *
+     * @param {*} id
+     */
+    remove(id, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!id)
+                throw new Error('missing id');
+            id = yield this.beforeRemove(id, context);
+            const res = yield this.mgModel.findByIdAndDelete(id);
+            this.publishCRUDEvent({ type: enums_1.ModelCrudEventType.remove, data: { uid: id, model: this.name } }, context);
+            return this.afterRemove(res, context);
+        });
+    }
+    /**
+     *
+     * @param {*} filter
+     * @param {*} callback
+     */
+    removeNative(filter, options) {
+        return this.mgModel.collection.deleteMany(filter, options);
+    }
+    /**
+     *
+     * @param items
+     * @param context
+     * @returns
+     */
+    bulkCreate(items, context) {
+        if (!items)
+            return Promise.resolve([]);
+        ;
+        let promises = items.map(item => this.create(item, context));
+        return Promise.all(promises);
+    }
+    /**
+     *
+     * @param ids
+     * @param items
+     * @param context
+     * @returns
+     */
+    bulkUpdate(ids, items, context) {
+        if (!items)
+            return Promise.resolve([]);
+        let promises = ids.map((id, index) => this.update(id, Array.isArray(items) ? items[index] : items, context));
+        return Promise.all(promises);
+    }
+    /**
+     *
+     * @param ids
+     * @param context
+     * @returns
+     */
+    bulkRemove(ids, context) {
+        if (!Array.isArray(ids))
+            return Promise.resolve([]);
+        ;
+        let promises = ids.map(id => this.remove(id, context));
+        return Promise.all(promises);
+    }
+    /**
+     *
+     * @param {*} evt
+     * @param {*} context
+     */
+    publishCRUDEvent(evt, context = {}) {
+        if (!this.defaultParams.CRUDEvents)
+            return;
+        if (context === null || context === void 0 ? void 0 : context.evtType)
+            evt.type = context.evtType;
+        constants_1.APP.nxPubSub.publish(constants_1.MODEL_CRUD_EVENT, evt, context);
+    }
+    /**
+     *
+     * @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_1) {
+        return __awaiter(this, arguments, void 0, function* (name, pipeline = [], callback = () => { }, duration) {
+            constants_1.APP.logger.info(`Adding new change stream [${name}] - duration ${duration || 'infinte'}`, (0, utils_1.logClassCtx)(this, 'addChangeStream'));
+            const csData = { name, duration, stream: this.mgModel.watch(pipeline) };
+            csData.stream.on('change', (next) => callback(name, next));
+            if (duration)
+                yield this.closeChangeStream(csData);
+            return csData;
+        });
+    }
+    /**
+     *
+     * @param {*} csData change stream data { name, duration, stream }
+     * @returns
+     */
+    closeChangeStream({ name, stream, duration }) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                constants_1.APP.logger.info(`Closing change stream [${name}]`, (0, utils_1.logClassCtx)(this, 'closeChangeStream'));
+                stream.close();
+                resolve();
+            }, duration || 60000);
+        });
+    }
+    ;
+}
+exports.BaseModel = BaseModel;