c2-mongoose 2.1.112 → 2.1.113

package/dist/flow/C2Flow.d.ts

@@ -1,8 +1,11 @@
-import mongoose from "mongoose";
+import mongoose, { Types } from "mongoose";
 import { Options } from "../types/Options";
+import SearchFlow from "./SearchFlow";
 declare class C2Flow<D> {
     private repository;
     constructor(repository: mongoose.Model<any>);
-    create(data: Partial<D>, options: Partial<Options>): Promise<any[]>;
+    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>>;
 }
 export default C2Flow;

package/dist/flow/C2Flow.js

@@ -54,13 +54,53 @@ var C2Flow = /** @class */ (function () {
                     case 1:
                         dataAfter = _a.sent();
                         if (options.logger === false) {
-                            return [2 /*return*/, dataAfter];
+                            return [2 /*return*/, dataAfter[0]._doc];
                         }
-                        log = BuildLogFlowItem_1.default.build(options, dataAfter, Logger_1.TypeOfOperation.CREATE);
+                        log = BuildLogFlowItem_1.default.build(options, dataAfter[0]._doc, Logger_1.TypeOfOperation.CREATE, this.repository);
                         return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
                     case 2:
                         _a.sent();
-                        return [2 /*return*/, dataAfter];
+                        return [2 /*return*/, dataAfter[0]._doc];
+                }
+            });
+        });
+    };
+    C2Flow.prototype.updateById = function (id, 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.findByIdAndUpdate(id, data, { returnDocument: 'after', session: options.session })];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/, dataAfter._doc];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, dataAfter._doc, Logger_1.TypeOfOperation.UPDATE, this.repository);
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, dataAfter._doc];
+                }
+            });
+        });
+    };
+    C2Flow.prototype.updateByModel = 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.findOneAndUpdate(searcher.filters, data, { session: options.session })];
+                    case 1:
+                        dataAfter = _a.sent();
+                        if (options.logger === false) {
+                            return [2 /*return*/, dataAfter._doc];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, dataAfter._doc, Logger_1.TypeOfOperation.UPDATE, this.repository);
+                        return [4 /*yield*/, global.LoggerRepository.create([log], { session: options.session })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, dataAfter._doc];
                 }
             });
         });

package/dist/flow/item/BuildLogFlowItem.d.ts

@@ -1,7 +1,8 @@
 import { ILogger, TypeOfOperation } from "../../model/Logger";
 import { Options } from "../../types/Options";
+import mongoose from "mongoose";
 declare class BuildLogFlowItem {
-    build(options: Partial<Options>, dataAfter: any[], operation: TypeOfOperation): Partial<ILogger>;
+    build(options: Partial<Options>, dataAfter: any[], operation: TypeOfOperation, repository: mongoose.Model<any>): Partial<ILogger>;
 }
 declare const _default: BuildLogFlowItem;
 export default _default;

package/dist/flow/item/BuildLogFlowItem.js

@@ -7,12 +7,13 @@ var express_http_context_1 = __importDefault(require("express-http-context"));
 var BuildLogFlowItem = /** @class */ (function () {
     function BuildLogFlowItem() {
     }
-    BuildLogFlowItem.prototype.build = function (options, dataAfter, operation) {
+    BuildLogFlowItem.prototype.build = function (options, dataAfter, operation, repository) {
         var _a;
         return {
             user: (_a = options.owner) !== null && _a !== void 0 ? _a : express_http_context_1.default.get("user")._id,
             owner: options.owner,
             data: dataAfter,
+            collection: repository.collection.name,
             operation: operation
         };
     };

package/dist/model/Logger.d.ts

@@ -9,6 +9,7 @@ declare enum TypeOfOperation {
 interface ILogger {
     owner: Types.ObjectId;
     user: Types.ObjectId;
+    collection: string;
     createdAtDateTime: moment.Moment;
     operation: TypeOfOperation;
     data: any;
@@ -18,6 +19,7 @@ declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, an
         createdAt: string;
     };
 }>, {
+    collection: string;
     owner: {
         prototype?: Types.ObjectId | undefined;
         cacheHexString?: unknown;
@@ -37,6 +39,7 @@ declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, an
     operation: string;
     data?: any;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
+    collection: string;
     owner: {
         prototype?: Types.ObjectId | undefined;
         cacheHexString?: unknown;
@@ -56,6 +59,7 @@ declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, an
     operation: string;
     data?: any;
 }>> & Omit<mongoose.FlatRecord<{
+    collection: string;
     owner: {
         prototype?: Types.ObjectId | undefined;
         cacheHexString?: unknown;

package/dist/model/Logger.js

@@ -55,6 +55,7 @@ exports.TypeOfOperation = TypeOfOperation;
 var LoggerModel = new mongoose_1.Schema({
     owner: { type: mongoose_1.Types.ObjectId, required: true, immutable: true },
     user: { type: mongoose_1.Types.ObjectId, required: true, immutable: true },
+    collection: { type: String, required: true, immutable: true },
     operation: { type: String, enum: TypeOfOperation, required: true, immutable: true },
     data: { type: mongoose_1.default.Schema.Types.Mixed, immutable: true }
 }, {

package/package.json

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

@@ -1,8 +1,9 @@
 
-import mongoose from "mongoose"
+import mongoose, { Types } from "mongoose"
 import { ILogger, TypeOfOperation } from "../model/Logger"
 import { Options } from "../types/Options"
 import BuildLogFlowItem from "./item/BuildLogFlowItem"
+import SearchFlow from "./SearchFlow"
 
 class C2Flow<D> {
 
@@ -12,29 +13,44 @@ class C2Flow<D> {
         this.repository = repository
     }
 
-    public async create(data: Partial<D>, options: Partial<Options>) {
+    async create(data: Partial<D>, options: Partial<Options>): Promise<Partial<D>> {
         let dataAfter = await this.repository.create([data], { session: options.session })
 
         if (options.logger === false) {
-            return dataAfter
+            return dataAfter[0]._doc
         }
 
-        let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter, TypeOfOperation.CREATE)
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter[0]._doc, TypeOfOperation.CREATE, this.repository)
         await (global as any).LoggerRepository.create([log], { session: options.session })
 
-        return dataAfter
+        return dataAfter[0]._doc
     }
 
+    async updateById(id: Types.ObjectId, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>> {
+        let dataAfter = await this.repository.findByIdAndUpdate(id, data, { returnDocument: 'after', session: options.session })
 
-    // public async updateById(id: Types.ObjectId, data: any, session: any = undefined): Promise<D> {
-    //     const dataAfter = await this.repository.findByIdAndUpdate(id, data, { returnDocument: 'after', session })
-    //     return dataAfter as D
-    // }
+        if (options.logger === false) {
+            return dataAfter._doc
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter._doc, TypeOfOperation.UPDATE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+
+        return dataAfter._doc
+    }
+
+    async updateByModel(searcher: SearchFlow, data: Partial<D>, options: Partial<Options>): Promise<Partial<D>> {
+        let dataAfter = await this.repository.findOneAndUpdate(searcher.filters, data, { session: options.session })
 
-    // public async updateByModel(searcher: SearchFlow, data: any, params: any): Promise<D> {
-    //     const dataAfter = await this.repository.findOneAndUpdate(searcher.filters, data, params)
-    //     return dataAfter as D
-    // }
+        if (options.logger === false) {
+            return dataAfter._doc
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, dataAfter._doc, TypeOfOperation.UPDATE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+
+        return dataAfter._doc
+    }
 }
 
 export default C2Flow

package/src/flow/item/BuildLogFlowItem.ts

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

package/src/model/Logger.ts

@@ -12,6 +12,7 @@ enum TypeOfOperation {
 interface ILogger {
   owner: Types.ObjectId
   user: Types.ObjectId
+  collection: string
   createdAtDateTime: moment.Moment
   operation: TypeOfOperation
   data: any
@@ -20,6 +21,7 @@ interface ILogger {
 const LoggerModel = new Schema({
   owner: { type: Types.ObjectId, required: true, immutable: true },
   user: { type: Types.ObjectId, required: true, immutable: true },
+  collection: { type: String, required: true, immutable: true },
   operation: { type: String, enum: TypeOfOperation, required: true, immutable: true },
   data: { type: mongoose.Schema.Types.Mixed, immutable: true }
 }, {