c2-mongoose 2.1.266 → 2.1.268

package/dist/flow/C2Flow.d.ts

@@ -8,8 +8,10 @@ declare class C2Flow<D> {
     createMany(data: Partial<D>[], options: Partial<Options>): Promise<Partial<D>[]>;
     updateById(_id: Types.ObjectId, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>>;
     updateByModel(searcher: SearchFlow, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>>;
+    updateByFilters(filters: any, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>>;
     updateMany(searcher: SearchFlow, data: D, options: Options): Promise<any>;
     deleteById(_id: Types.ObjectId, options: Partial<Options>): Promise<void>;
     deleteByModel(searcher: SearchFlow, options: Partial<Options>): Promise<void>;
+    deleteByFilters(filters: any, options: Partial<Options>): Promise<void>;
 }
 export default C2Flow;

package/dist/flow/C2Flow.js

@@ -155,6 +155,35 @@ var C2Flow = /** @class */ (function () {
             });
         });
     };
+    C2Flow.prototype.updateByFilters = function (filters, data, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataAfter, log;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repository.findOneAndUpdate(filters, data, { returnDocument: 'after', session: options.session })];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            if ((0, Utils_1.isEmpty)(dataAfter)) {
+                                return [2 /*return*/, dataAfter];
+                            }
+                            return [2 /*return*/, dataAfter._doc];
+                        }
+                        if ((0, Utils_1.isEmpty)(dataAfter)) {
+                            return [2 /*return*/, dataAfter];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, __assign({ _id: dataAfter._id }, data), Logger_1.TypeOfOperation.UPDATE, this.repository);
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        if ((0, Utils_1.isEmpty)(dataAfter)) {
+                            return [2 /*return*/, dataAfter];
+                        }
+                        return [2 /*return*/, dataAfter._doc];
+                }
+            });
+        });
+    };
     C2Flow.prototype.updateMany = function (searcher, data, options) {
         return __awaiter(this, void 0, void 0, function () {
             var dataAfter, log;
@@ -224,6 +253,26 @@ var C2Flow = /** @class */ (function () {
             });
         });
     };
+    C2Flow.prototype.deleteByFilters = function (filters, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var dataAfter, log;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.repository.deleteMany(filters).session(options.session)];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, __assign(__assign({}, filters), dataAfter), Logger_1.TypeOfOperation.DELETE, this.repository);
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     return C2Flow;
 }());
 exports.default = C2Flow;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.266",
+  "version": "2.1.268",
   "description": "Lib to make any search in database mongoose and use as basic crud",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/flow/C2Flow.ts

@@ -83,6 +83,28 @@ class C2Flow<D> {
         return dataAfter._doc
     }
 
+    async updateByFilters(filters: any, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>> {
+        let dataAfter = await this.repository.findOneAndUpdate(filters, data, { returnDocument: 'after', session: options.session })
+
+        if (options.logger === false) {
+            if (isEmpty(dataAfter)) {
+                return dataAfter
+            }
+            return dataAfter._doc
+        }
+
+        if (isEmpty(dataAfter)) {
+            return dataAfter
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, { _id: dataAfter._id, ...data }, TypeOfOperation.UPDATE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+        if (isEmpty(dataAfter)) {
+            return dataAfter
+        }
+        return dataAfter._doc
+    }
+
     async updateMany(searcher: SearchFlow, data: D, options: Options): Promise<any> {
         let dataAfter = await this.repository.updateMany(searcher.filters, data as Partial<D>, { returnDocument: 'after', session: options.session })
         if (options.logger === false) {
@@ -128,6 +150,18 @@ class C2Flow<D> {
         let log: Partial<ILogger> = BuildLogFlowItem.build(options, { ...searcher.filters, ...dataAfter }, TypeOfOperation.DELETE, this.repository)
         await (global as any).LoggerRepository.create([log], { session: options.session })
     }
+
+    public async deleteByFilters(filters: any, options: Partial<Options>) {
+
+        let dataAfter = await this.repository.deleteMany(filters).session(options.session!)
+
+        if (options.logger === false) {
+            return
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, { ...filters, ...dataAfter }, TypeOfOperation.DELETE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+    }
 }
 
 export default C2Flow