c2-mongoose 2.1.235 → 2.1.240

package/dist/flow/C2Flow.d.ts

@@ -8,6 +8,7 @@ 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>>;
+    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>;
 }

package/dist/flow/C2Flow.js

@@ -155,6 +155,35 @@ var C2Flow = /** @class */ (function () {
             });
         });
     };
+    C2Flow.prototype.updateMany = 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.updateMany(searcher.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];
+                        }
+                        if ((0, Utils_1.isEmpty)(dataAfter)) {
+                            return [2 /*return*/, dataAfter];
+                        }
+                        log = BuildLogFlowItem_1.default.build(options, __assign({ filters: searcher.filters }, 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];
+                }
+            });
+        });
+    };
     C2Flow.prototype.deleteById = function (_id, options) {
         return __awaiter(this, void 0, void 0, function () {
             var dataAfter, log;

package/dist/flow/SearcherFlow.d.ts

@@ -1,4 +1,4 @@
-import mongoose from "mongoose";
+import mongoose, { Schema } from "mongoose";
 import { SearchOptions, SearchResponse } from "../types/SearchResponse";
 export interface IPopulate {
     [key: string]: any;
@@ -22,6 +22,7 @@ declare class SearcherFlow<D> {
     prepareSearch(search: any): void;
     search(options: SearchOptions): Promise<SearchResponse<D>>;
     transformObject(originalObject: any): any;
+    extractFieldsOfType(schema: Schema, typing?: string, parent?: string): string[];
     buildDefaultFilters(objectSearch: any): any;
     isValidObjectId(value: string): boolean;
     buildOrdenation(): any;

package/dist/flow/SearcherFlow.js

@@ -46,6 +46,15 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -178,12 +187,25 @@ var SearcherFlow = /** @class */ (function () {
         var hasPagination = (originalObject === null || originalObject === void 0 ? void 0 : originalObject.paging) ? true : false;
         return __assign(__assign({}, transformedObject), { metadata: metadata, paging: hasPagination ? (originalObject === null || originalObject === void 0 ? void 0 : originalObject.paging[0]) || { total: 0, page: 1, limit: this.limit } : undefined });
     };
+    SearcherFlow.prototype.extractFieldsOfType = function (schema, typing, parent) {
+        var _this = this;
+        if (typing === void 0) { typing = 'String'; }
+        if (parent === void 0) { parent = ''; }
+        var fieldsTyped = [];
+        Object.keys(schema.paths).forEach(function (field) {
+            if (schema.paths[field].instance === typing) {
+                fieldsTyped.push("".concat(parent !== '' ? "".concat(parent, ".") : '').concat(field));
+            }
+            else if (schema.paths[field].instance === 'Embedded') {
+                fieldsTyped = __spreadArray(__spreadArray([], fieldsTyped, true), _this.extractFieldsOfType(schema.paths[field].schema, typing, field), true);
+            }
+        });
+        return fieldsTyped;
+    };
     SearcherFlow.prototype.buildDefaultFilters = function (objectSearch) {
         var _this = this;
         // Recuperar todos os campos do tipo String
-        var camposString = Object.keys(this.model.schema.paths).filter(function (campo) {
-            return _this.model.schema.paths[campo].instance === 'String';
-        });
+        var camposString = this.extractFieldsOfType(this.model.schema, 'String');
         var filters = { $and: [] };
         Object.entries(objectSearch).forEach(function (_a) {
             var key = _a[0], value = _a[1];

package/dist/model/Logger.d.ts

@@ -13,6 +13,8 @@ interface ILogger {
     createdAtDateTime: moment.Moment;
     operation: TypeOfOperation;
     data: any;
+    filters: any;
+    notes: string;
 }
 declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, any, any, any>, {}, {}, {}, {}, mongoose.ResolveSchemaOptions<{
     timestamps: {
@@ -25,18 +27,24 @@ declare const LoggerModel: mongoose.Schema<any, mongoose.Model<any, any, any, an
     collectionName: string;
     operation: string;
     data?: any;
+    filters?: any;
+    notes?: string | undefined;
 }, mongoose.Document<unknown, {}, mongoose.FlatRecord<{
     owner: Types.ObjectId;
     user: Types.ObjectId;
     collectionName: string;
     operation: string;
     data?: any;
+    filters?: any;
+    notes?: string | undefined;
 }>> & Omit<mongoose.FlatRecord<{
     owner: Types.ObjectId;
     user: Types.ObjectId;
     collectionName: string;
     operation: string;
     data?: any;
+    filters?: any;
+    notes?: string | undefined;
 }> & {
     _id: Types.ObjectId;
 }, never>>;

package/dist/model/Logger.js

@@ -57,7 +57,9 @@ var LoggerModel = new mongoose_1.Schema({
     user: { type: mongoose_1.default.Schema.Types.ObjectId, required: true, immutable: true },
     collectionName: { 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 }
+    data: { type: mongoose_1.default.Schema.Types.Mixed, immutable: true },
+    filters: { type: mongoose_1.default.Schema.Types.Mixed, immutable: true },
+    notes: { type: String, immutable: true }
 }, {
     timestamps: { createdAt: 'createdAtDateTime', updatedAt: 'updatedAtDateTime' }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.235",
+  "version": "2.1.240",
   "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,5 +1,5 @@
 
-import mongoose, { Types } from "mongoose"
+import mongoose, { QueryWithHelpers, Types, UpdateWriteOpResult } from "mongoose"
 import { ILogger, TypeOfOperation } from "../model/Logger"
 import { Options } from "../types/Options"
 import BuildLogFlowItem from "./item/BuildLogFlowItem"
@@ -83,6 +83,27 @@ class C2Flow<D> {
         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) {
+            if (isEmpty(dataAfter)) {
+                return dataAfter
+            }
+            return dataAfter
+        }
+
+        if (isEmpty(dataAfter)) {
+            return dataAfter
+        }
+
+        let log: Partial<ILogger> = BuildLogFlowItem.build(options, { filters: searcher.filters, ...data }, TypeOfOperation.UPDATE, this.repository)
+        await (global as any).LoggerRepository.create([log], { session: options.session })
+        if (isEmpty(dataAfter)) {
+            return dataAfter
+        }
+        return dataAfter
+    }
+
 
     public async deleteById(_id: Types.ObjectId, options: Partial<Options>) {
 

package/src/flow/SearcherFlow.ts

@@ -1,5 +1,5 @@
 import moment from "moment"
-import mongoose, { ClientSession, Types } from "mongoose"
+import mongoose, { ClientSession, Schema, Types } from "mongoose"
 import { SearchOptions, SearchResponse } from "../types/SearchResponse"
 import { isNotEmpty } from "../utils/Utils"
 import BuildPopulateSingleFlowItem from "./item/BuildPopulateSingleFlowItem"
@@ -152,12 +152,23 @@ class SearcherFlow<D> {
         };
     }
 
+    extractFieldsOfType(schema: Schema, typing = 'String', parent = ''): string[]{
+        let fieldsTyped: string[] = []
+        Object.keys(schema.paths).forEach((field: string) => {
+            if (schema.paths[field].instance === typing) {
+                fieldsTyped.push(`${parent !== '' ? `${parent}.` : ''}${field}`)
+            } else if (schema.paths[field].instance === 'Embedded') {
+                fieldsTyped = [...fieldsTyped, ...this.extractFieldsOfType(schema.paths[field].schema, typing, field)]
+            }
+        })
+
+        return fieldsTyped
+    }
+
     public buildDefaultFilters(objectSearch: any) {
 
         // Recuperar todos os campos do tipo String
-        const camposString = Object.keys(this.model.schema.paths).filter((campo: string) => {
-            return this.model.schema.paths[campo].instance === 'String';
-        });
+        const camposString = this.extractFieldsOfType(this.model.schema, 'String')
 
 
         let filters = { $and: [] } as any

package/src/model/Logger.ts

@@ -16,6 +16,8 @@ interface ILogger {
   createdAtDateTime: moment.Moment
   operation: TypeOfOperation
   data: any
+  filters: any
+  notes: string
 }
 
 const LoggerModel = new Schema({
@@ -23,7 +25,9 @@ const LoggerModel = new Schema({
   user: { type: mongoose.Schema.Types.ObjectId, required: true, immutable: true },
   collectionName: { type: String, required: true, immutable: true },
   operation: { type: String, enum: TypeOfOperation, required: true, immutable: true },
-  data: { type: mongoose.Schema.Types.Mixed, immutable: true }
+  data: { type: mongoose.Schema.Types.Mixed, immutable: true },
+  filters: { type: mongoose.Schema.Types.Mixed, immutable: true },
+  notes: { type: String, immutable: true }
 }, {
   timestamps: { createdAt: 'createdAtDateTime', updatedAt: 'updatedAtDateTime' }
 })