c2-mongoose 2.1.111 → 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);
-                        return [4 /*yield*/, Logger_1.LoggerRepository.create([log], { session: options.session })];
+                        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/index.d.ts

@@ -1,7 +1,8 @@
 import C2Flow from "./flow/C2Flow";
 import CrudFlow from "./flow/CrudFlow";
 import SearchFlow from "./flow/SearchFlow";
-import { ILogger, LoggerModel, LoggerRepository, LoggerSearch, TypeOfOperation } from "./model/Logger";
+import { ILogger, LoggerModel, LoggerSearch, TypeOfOperation } from "./model/Logger";
 import { Options } from "./types/Options";
 import { Pagination, SearchResponse } from "./types/SearchResponse";
-export { CrudFlow, C2Flow, Options, SearchFlow, SearchResponse, Pagination, ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch };
+import { initialize } from "./utils/Utils";
+export { C2Flow, CrudFlow, ILogger, LoggerModel, LoggerSearch, Options, Pagination, SearchFlow, SearchResponse, TypeOfOperation, initialize };

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerSearch = exports.LoggerRepository = exports.LoggerModel = exports.TypeOfOperation = exports.SearchFlow = exports.C2Flow = exports.CrudFlow = void 0;
+exports.initialize = exports.TypeOfOperation = exports.SearchFlow = exports.LoggerSearch = exports.LoggerModel = exports.CrudFlow = exports.C2Flow = void 0;
 var C2Flow_1 = __importDefault(require("./flow/C2Flow"));
 exports.C2Flow = C2Flow_1.default;
 var CrudFlow_1 = __importDefault(require("./flow/CrudFlow"));
@@ -12,6 +12,8 @@ var SearchFlow_1 = __importDefault(require("./flow/SearchFlow"));
 exports.SearchFlow = SearchFlow_1.default;
 var Logger_1 = require("./model/Logger");
 Object.defineProperty(exports, "LoggerModel", { enumerable: true, get: function () { return Logger_1.LoggerModel; } });
-Object.defineProperty(exports, "LoggerRepository", { enumerable: true, get: function () { return Logger_1.LoggerRepository; } });
 Object.defineProperty(exports, "LoggerSearch", { enumerable: true, get: function () { return Logger_1.LoggerSearch; } });
 Object.defineProperty(exports, "TypeOfOperation", { enumerable: true, get: function () { return Logger_1.TypeOfOperation; } });
+var Utils_1 = require("./utils/Utils");
+Object.defineProperty(exports, "initialize", { enumerable: true, get: function () { return Utils_1.initialize; } });
+global.LoggerRepository = undefined;

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;
@@ -82,127 +86,4 @@ declare class LoggerSearch extends SearchFlow {
     constructor(params: any);
     buildFilters(): void;
 }
-declare const LoggerRepository: mongoose.Model<{
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-}, {}, {}, {}, mongoose.Document<unknown, {}, {
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-}> & Omit<{
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-} & {
-    _id: Types.ObjectId;
-}, never>, mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.ResolveSchemaOptions<{
-    timestamps: {
-        createdAt: string;
-    };
-}>, {
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-}, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-}>> & Omit<mongoose.FlatRecord<{
-    owner: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    user: {
-        prototype?: Types.ObjectId | undefined;
-        cacheHexString?: unknown;
-        generate?: {} | undefined;
-        createFromTime?: {} | undefined;
-        createFromHexString?: {} | undefined;
-        isValid?: {} | undefined;
-    };
-    operation: string;
-    data?: any;
-}> & {
-    _id: Types.ObjectId;
-}, never>>>;
-export { ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch };
+export { ILogger, TypeOfOperation, LoggerModel, LoggerSearch };

package/dist/model/Logger.js

@@ -41,7 +41,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LoggerSearch = exports.LoggerRepository = exports.LoggerModel = exports.TypeOfOperation = void 0;
+exports.LoggerSearch = exports.LoggerModel = exports.TypeOfOperation = void 0;
 var mongoose_1 = __importStar(require("mongoose"));
 var SearchFlow_1 = __importDefault(require("../flow/SearchFlow"));
 var Utils_1 = require("../utils/Utils");
@@ -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 }
 }, {
@@ -90,6 +91,3 @@ var LoggerSearch = /** @class */ (function (_super) {
     return LoggerSearch;
 }(SearchFlow_1.default));
 exports.LoggerSearch = LoggerSearch;
-var LoggerRepository = (0, mongoose_1.model)('testeLogger', LoggerModel);
-exports.LoggerRepository = LoggerRepository;
-LoggerRepository.createCollection();

package/dist/utils/Utils.d.ts

@@ -1,3 +1,5 @@
+import { Connection } from "mongoose";
+export declare const initialize: (connection: Connection) => void;
 export declare const isNotEmpty: (obj: any) => boolean;
 export declare const isEmpty: (obj: any) => boolean;
 export declare const isIterable: (input: any) => boolean;

package/dist/utils/Utils.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.compareDesc = exports.compareAsc = exports.isNotIterable = exports.isIterable = exports.isEmpty = exports.isNotEmpty = void 0;
+exports.compareDesc = exports.compareAsc = exports.isNotIterable = exports.isIterable = exports.isEmpty = exports.isNotEmpty = exports.initialize = void 0;
+var Logger_1 = require("../model/Logger");
+var initialize = function (connection) {
+    global.LoggerRepository = connection.model('c2-mongoose-logger', Logger_1.LoggerModel);
+};
+exports.initialize = initialize;
 var isNotEmpty = function (obj) {
     return !(0, exports.isEmpty)(obj);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.111",
+  "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 { ILogger, LoggerRepository, TypeOfOperation } from "../model/Logger"
+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)
-        await LoggerRepository.create([log], { session: options.session })
+        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/index.ts

@@ -1,9 +1,12 @@
-import mongoose from "mongoose"
 import C2Flow from "./flow/C2Flow"
 import CrudFlow from "./flow/CrudFlow"
 import SearchFlow from "./flow/SearchFlow"
-import { ILogger, LoggerModel, LoggerRepository, LoggerSearch, TypeOfOperation } from "./model/Logger"
+import { ILogger, LoggerModel, LoggerSearch, TypeOfOperation } from "./model/Logger"
 import { Options } from "./types/Options"
 import { Pagination, SearchResponse } from "./types/SearchResponse"
+import { initialize } from "./utils/Utils"
+
+(global as any).LoggerRepository = undefined
+
+export { C2Flow, CrudFlow, ILogger, LoggerModel, LoggerSearch, Options, Pagination, SearchFlow, SearchResponse, TypeOfOperation, initialize }
 
-export { CrudFlow, C2Flow, Options, SearchFlow, SearchResponse, Pagination, ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch }

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 }
 }, {
@@ -57,7 +59,5 @@ class LoggerSearch extends SearchFlow {
   }
 }
 
-const LoggerRepository = model('testeLogger', LoggerModel)
 
-LoggerRepository.createCollection()
-export { ILogger, TypeOfOperation, LoggerModel, LoggerRepository, LoggerSearch }
+export { ILogger, TypeOfOperation, LoggerModel, LoggerSearch }

package/src/utils/Utils.ts

@@ -1,3 +1,11 @@
+import { Connection } from "mongoose"
+import { LoggerModel } from "../model/Logger"
+
+export const initialize = (connection: Connection) => {
+
+    (global as any).LoggerRepository = connection.model('c2-mongoose-logger', LoggerModel)
+}
+
 export const isNotEmpty = (obj: any) => {
     return !isEmpty(obj)
 }