c2-mongoose 2.1.116 → 2.1.118

package/dist/flow/C2Flow.d.ts

@@ -7,5 +7,7 @@ declare class C2Flow<D> {
     create(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>>;
+    deleteById(_id: Types.ObjectId, options: Partial<Options>): Promise<void>;
+    deleteByModel(searcher: SearchFlow, data: Partial<D>, options: Partial<Options>): Promise<void>;
 }
 export default C2Flow;

package/dist/flow/C2Flow.js

@@ -116,6 +116,46 @@ var C2Flow = /** @class */ (function () {
             });
         });
     };
+    C2Flow.prototype.deleteById = function (_id, 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.findByIdAndRemove(_id, { session: options.session })];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, __assign({ _id: _id }, dataAfter._doc), Logger_1.TypeOfOperation.DELETE, this.repository);
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    C2Flow.prototype.deleteByModel = function (searcher, 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.deleteMany(searcher.filters).session(options.session)];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, __assign(__assign({}, searcher.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/dist/flow/item/BuildLogFlowItem.js

@@ -4,14 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var express_http_context_1 = __importDefault(require("express-http-context"));
+var mongoose_1 = require("mongoose");
 var BuildLogFlowItem = /** @class */ (function () {
     function BuildLogFlowItem() {
     }
     BuildLogFlowItem.prototype.build = function (options, dataAfter, operation, repository) {
         var _a;
         return {
-            user: (_a = options.user) !== null && _a !== void 0 ? _a : express_http_context_1.default.get("user")._id,
-            owner: options.owner,
+            user: new mongoose_1.Types.ObjectId((_a = options.user) !== null && _a !== void 0 ? _a : express_http_context_1.default.get("user")._id),
+            owner: new mongoose_1.Types.ObjectId(options.owner),
             data: dataAfter,
             collectionName: repository.collection.name,
             operation: operation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.116",
+  "version": "2.1.118",
   "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

@@ -51,6 +51,31 @@ class C2Flow<D> {
 
         return dataAfter._doc
     }
+
+
+    public async deleteById(_id: Types.ObjectId, options: Partial<Options>) {
+
+        let dataAfter = await this.repository.findByIdAndRemove(_id, { session: options.session })
+
+        if (options.logger === false) {
+            return
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, { _id, ...dataAfter._doc }, TypeOfOperation.DELETE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+    }
+
+    public async deleteByModel(searcher: SearchFlow, data: Partial<D>, options: Partial<Options>) {
+
+        let dataAfter = await this.repository.deleteMany(searcher.filters).session(options.session!)
+
+        if (options.logger === false) {
+            return
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, { ...searcher.filters, ...dataAfter }, TypeOfOperation.DELETE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+    }
 }
 
 export default C2Flow

package/src/flow/item/BuildLogFlowItem.ts

@@ -1,13 +1,13 @@
 import httpContext from "express-http-context"
 import { ILogger, TypeOfOperation } from "../../model/Logger"
 import { Options } from "../../types/Options"
-import mongoose from "mongoose"
+import mongoose, { Types } from "mongoose"
 
 class BuildLogFlowItem {
   build(options: Partial<Options>, dataAfter: any, operation: TypeOfOperation, repository: mongoose.Model<any>): Partial<ILogger> {
     return {
-      user: options.user ?? httpContext.get("user")._id,
-      owner: options.owner,
+      user: new Types.ObjectId(options.user ?? httpContext.get("user")._id),
+      owner: new Types.ObjectId(options.owner),
       data: dataAfter,
       collectionName: repository.collection.name,
       operation