c2-mongoose 2.1.123 → 2.1.125

package/dist/flow/CrudFlow.d.ts

@@ -12,7 +12,7 @@ declare class CrudFlow<D> {
     update(id: string, data: D, session?: any): Promise<D>;
     updateAny(id: string, data: any, session?: any): Promise<D>;
     updateByModel(filter: any, data: any, params: any): Promise<D>;
-    find(options?: SearchOptions): Promise<SearchResponse<D>>;
+    find(options: SearchOptions): Promise<SearchResponse<D>>;
     getOne(model: D, session?: ClientSession): Promise<D>;
     get(id: string, pop?: string, sel?: string, session?: ClientSession): Promise<D>;
     getById(id: string, session?: ClientSession): Promise<Partial<D>>;

package/dist/flow/SearchFlow.d.ts

@@ -23,18 +23,10 @@ declare abstract class SearchFlow {
     buildPath(target: string, nested?: string): any;
     buildOrdenation(): any;
     buildRegex(searchText: string): RegExp;
+    searchNoPageable(model: mongoose.Model<any>, options: SearchOptions): Promise<any>;
     searchPageable(model: mongoose.Model<any>, options: SearchOptions): Promise<any>;
     transformObject(originalObject: any): any;
-    search(model: mongoose.Model<any>, options?: SearchOptions): Promise<SearchResponse<any>>;
-    /**
-     *
-     * @param model
-     * @deprecated
-     * @returns
-     */
-    private searchPageableOld;
-    private searchNoPageable;
-    private result;
+    search(model: mongoose.Model<any>, options: SearchOptions): Promise<SearchResponse<any>>;
     count(model: mongoose.Model<any>): Promise<number>;
     findOne(repository: mongoose.Model<any>, model: any, session?: ClientSession): Promise<any>;
     sumBy(model: mongoose.Model<any>, _sum: any, _by: any, items?: any, session?: ClientSession): Promise<any[]>;

package/dist/flow/SearchFlow.js

@@ -52,39 +52,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var moment_1 = __importDefault(require("moment"));
 var mongoose_1 = require("mongoose");
-var Environment_1 = require("../configuration/Environment");
 var Utils_1 = require("../utils/Utils");
 var SearchFlow = /** @class */ (function () {
     function SearchFlow(params) {
-        var _this = this;
-        /**
-         *
-         * @param model
-         * @deprecated
-         * @returns
-         */
-        this.searchPageableOld = function (model, session) { return __awaiter(_this, void 0, void 0, function () {
-            var sort, items;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sort = this.buildOrdenation();
-                        return [4 /*yield*/, model
-                                .find(this.filters, this.select)
-                                .populate(this.populate)
-                                .skip((this.page - 1) * this.limit)
-                                .limit(this.limit)
-                                .sort(sort)
-                                .session(session)
-                                .collation({
-                                locale: Environment_1.dbCollation || "pt"
-                            })];
-                    case 1:
-                        items = _a.sent();
-                        return [2 /*return*/, this.result(model, items)];
-                }
-            });
-        }); };
         this.searchText = params.searchText || "";
         this.order = params.order || "asc";
         this.orderBy = params.orderBy || "_id";
@@ -184,9 +154,67 @@ var SearchFlow = /** @class */ (function () {
             .replace(/[u|ü|ú|ù|U|Ú|Ü|Ù]/g, '[u,ü,ú,ù,U,Ú,Ü,Ù]');
         return new RegExp("".concat(regexExpression), 'i');
     };
+    SearchFlow.prototype.searchNoPageable = function (model, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stagesItems, stagesMetadata, facet, _i, stagesMetadata_1, metadata, result, items, _a, _b, populate, resultAux;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        stagesItems = [{ $match: this.filters }];
+                        if ((0, Utils_1.isNotEmpty)(options.unions)) {
+                            stagesItems.push.apply(stagesItems, options.unions);
+                        }
+                        if ((0, Utils_1.isNotEmpty)(this.projection)) {
+                            stagesItems.push({ $project: this.projection });
+                        }
+                        if ((0, Utils_1.isNotEmpty)(options.pipelines)) {
+                            stagesItems.push.apply(stagesItems, options.pipelines);
+                        }
+                        stagesItems.push({ $sort: this.sort });
+                        stagesItems.push({ $skip: ((this.page - 1) * this.limit) || 0 });
+                        stagesItems.push({ $limit: this.limit });
+                        stagesMetadata = [];
+                        if ((0, Utils_1.isNotEmpty)(options.metadata)) {
+                            stagesMetadata.push.apply(stagesMetadata, options.metadata);
+                        }
+                        facet = {
+                            items: stagesItems
+                        };
+                        for (_i = 0, stagesMetadata_1 = stagesMetadata; _i < stagesMetadata_1.length; _i++) {
+                            metadata = stagesMetadata_1[_i];
+                            facet[metadata.id] = metadata.conditions;
+                        }
+                        return [4 /*yield*/, model.aggregate([
+                                {
+                                    $facet: facet
+                                },
+                            ]).session(options === null || options === void 0 ? void 0 : options.session)];
+                    case 1:
+                        result = _c.sent();
+                        items = result[0].items;
+                        if (!((0, Utils_1.isNotEmpty)(this.populate) && Array.isArray(this.populate))) return [3 /*break*/, 5];
+                        _a = 0, _b = this.populate;
+                        _c.label = 2;
+                    case 2:
+                        if (!(_a < _b.length)) return [3 /*break*/, 5];
+                        populate = _b[_a];
+                        return [4 /*yield*/, model.populate(result[0].items, populate)];
+                    case 3:
+                        items = _c.sent();
+                        _c.label = 4;
+                    case 4:
+                        _a++;
+                        return [3 /*break*/, 2];
+                    case 5:
+                        resultAux = this.transformObject(result[0]);
+                        return [2 /*return*/, resultAux];
+                }
+            });
+        });
+    };
     SearchFlow.prototype.searchPageable = function (model, options) {
         return __awaiter(this, void 0, void 0, function () {
-            var stagesItems, stagesPaging, stagesMetadata, facet, _i, stagesMetadata_1, metadata, result, items, _a, _b, populate, resultAux;
+            var stagesItems, stagesPaging, stagesMetadata, facet, _i, stagesMetadata_2, metadata, result, items, _a, _b, populate, resultAux;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -217,8 +245,8 @@ var SearchFlow = /** @class */ (function () {
                             items: stagesItems,
                             paging: stagesPaging,
                         };
-                        for (_i = 0, stagesMetadata_1 = stagesMetadata; _i < stagesMetadata_1.length; _i++) {
-                            metadata = stagesMetadata_1[_i];
+                        for (_i = 0, stagesMetadata_2 = stagesMetadata; _i < stagesMetadata_2.length; _i++) {
+                            metadata = stagesMetadata_2[_i];
                             facet[metadata.id] = metadata.conditions;
                         }
                         return [4 /*yield*/, model.aggregate([
@@ -244,13 +272,7 @@ var SearchFlow = /** @class */ (function () {
                         return [3 /*break*/, 2];
                     case 5:
                         resultAux = this.transformObject(result[0]);
-                        return [2 /*return*/, resultAux
-                            // return {
-                            //   ...result[0],
-                            //   items,
-                            //   paging: result[0]?.paging[0] || { total: 0, page: 1, limit: this.limit },
-                            // }
-                        ];
+                        return [2 /*return*/, resultAux];
                 }
             });
         });
@@ -266,66 +288,19 @@ var SearchFlow = /** @class */ (function () {
                 transformedObject[key] = originalObject[key];
             }
         }
-        return __assign(__assign({}, transformedObject), { metadata: metadata, paging: (originalObject === null || originalObject === void 0 ? void 0 : originalObject.paging[0]) || { total: 0, page: 1, limit: this.limit } });
+        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 });
     };
     SearchFlow.prototype.search = function (model, options) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
-                        if (!(this.pageable == true)) return [3 /*break*/, 4];
-                        if (!(options === null || options === void 0 ? void 0 : options.pipelines)) return [3 /*break*/, 2];
+                        if (!(this.pageable == true)) return [3 /*break*/, 2];
                         return [4 /*yield*/, this.searchPageable(model, options)];
                     case 1: return [2 /*return*/, _a.sent()];
-                    case 2: return [4 /*yield*/, this.searchPageableOld(model, options === null || options === void 0 ? void 0 : options.session)];
+                    case 2: return [4 /*yield*/, this.searchNoPageable(model, options)];
                     case 3: return [2 /*return*/, _a.sent()];
-                    case 4: return [4 /*yield*/, this.searchNoPageable(model, options === null || options === void 0 ? void 0 : options.session)];
-                    case 5: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    SearchFlow.prototype.searchNoPageable = function (model, session) {
-        return __awaiter(this, void 0, void 0, function () {
-            var sort, items;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        sort = this.buildOrdenation();
-                        return [4 /*yield*/, model
-                                .find(this.filters, this.select)
-                                .populate(this.populate)
-                                .sort(sort)
-                                .session(session)
-                                .collation({
-                                locale: Environment_1.dbCollation || "pt"
-                            })];
-                    case 1:
-                        items = _a.sent();
-                        return [2 /*return*/, this.result(model, items)];
-                }
-            });
-        });
-    };
-    SearchFlow.prototype.result = function (model, items) {
-        return __awaiter(this, void 0, void 0, function () {
-            var searchResponse, total, paging;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        searchResponse = {};
-                        searchResponse.items = items;
-                        if (!(this.pageable == true)) return [3 /*break*/, 2];
-                        return [4 /*yield*/, this.count(model)];
-                    case 1:
-                        total = _a.sent();
-                        paging = {};
-                        paging.total = total;
-                        paging.page = Number(this.page);
-                        paging.limit = Number(this.limit);
-                        searchResponse.paging = paging;
-                        _a.label = 2;
-                    case 2: return [2 /*return*/, searchResponse];
                 }
             });
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.123",
+  "version": "2.1.125",
   "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/CrudFlow.ts

@@ -44,7 +44,7 @@ class CrudFlow<D> {
         return dataAfter as D
     }
 
-    public async find(options?: SearchOptions): Promise<SearchResponse<D>> {
+    public async find(options: SearchOptions): Promise<SearchResponse<D>> {
         return await this.search.search(this.repository, options)
     }
 

package/src/flow/SearchFlow.ts

@@ -1,7 +1,6 @@
 import moment from "moment"
 import mongoose, { ClientSession, Types } from "mongoose"
-import { dbCollation } from "../configuration/Environment"
-import { Pagination, SearchOptions, SearchResponse } from "../types/SearchResponse"
+import { SearchOptions, SearchResponse } from "../types/SearchResponse"
 import { isEmpty, isNotEmpty } from "../utils/Utils"
 
 abstract class SearchFlow {
@@ -122,6 +121,60 @@ abstract class SearchFlow {
     return new RegExp(`${regexExpression}`, 'i');
   }
 
+  async searchNoPageable(model: mongoose.Model<any>, options: SearchOptions) {
+
+    let stagesItems: any[] = [{ $match: this.filters }]
+
+    if (isNotEmpty(options.unions)) {
+      stagesItems.push(...options.unions)
+    }
+
+    if (isNotEmpty(this.projection)) {
+      stagesItems.push({ $project: this.projection })
+    }
+
+    if (isNotEmpty(options.pipelines)) {
+      stagesItems.push(...options.pipelines)
+    }
+
+    stagesItems.push({ $sort: this.sort })
+    stagesItems.push({ $skip: ((this.page - 1) * this.limit) || 0 })
+    stagesItems.push({ $limit: this.limit })
+
+    let stagesMetadata: any[] = []
+    if (isNotEmpty(options.metadata)) {
+      stagesMetadata.push(...options.metadata)
+    }
+
+
+    const facet: { [key: string]: any } = {
+      items: stagesItems
+    }
+
+    for (let metadata of stagesMetadata) {
+      facet[metadata.id] = metadata.conditions
+    }
+
+    const result = await model.aggregate(
+      [
+        {
+          $facet: facet
+        },
+      ]
+    ).session(options?.session as ClientSession)
+
+    var items = result[0].items
+
+    if (isNotEmpty(this.populate) && Array.isArray(this.populate)) {
+      for (var populate of this.populate) {
+        items = await model.populate(result[0].items, populate)
+      }
+    }
+
+    let resultAux = this.transformObject(result[0])
+    return resultAux
+  }
+
   async searchPageable(model: mongoose.Model<any>, options: SearchOptions) {
 
     let stagesItems: any[] = [{ $match: this.filters }]
@@ -185,17 +238,12 @@ abstract class SearchFlow {
 
     let resultAux = this.transformObject(result[0])
     return resultAux
-    // return {
-    //   ...result[0],
-    //   items,
-    //   paging: result[0]?.paging[0] || { total: 0, page: 1, limit: this.limit },
-    // }
   }
 
   transformObject(originalObject: any): any {
     const metadata: any = {};
     const transformedObject: any = {};
-  
+
     for (const key in originalObject) {
       if (key.startsWith('metadata-')) {
         metadata[key.replace("metadata-", "")] = originalObject[key][0];
@@ -203,75 +251,22 @@ abstract class SearchFlow {
         transformedObject[key] = originalObject[key];
       }
     }
-  
+
+    let hasPagination = originalObject?.paging ? true : false
+
     return {
       ...transformedObject,
       metadata,
-      paging: originalObject?.paging[0] || { total: 0, page: 1, limit: this.limit },
+      paging: hasPagination ? originalObject?.paging[0] || { total: 0, page: 1, limit: this.limit } : undefined,
     };
   }
 
-  public async search(model: mongoose.Model<any>, options?: SearchOptions): Promise<SearchResponse<any>> {
-    if (this.pageable == true) {
-      if (options?.pipelines) {
-        return await this.searchPageable(model, options)
-      }
-      return await this.searchPageableOld(model, options?.session)
-    }
-
-    return await this.searchNoPageable(model, options?.session)
-  }
-
-  /**
-   * 
-   * @param model
-   * @deprecated
-   * @returns 
-   */
-  private searchPageableOld = async (model: mongoose.Model<any>, session?: ClientSession): Promise<SearchResponse<any>> => {
-    const sort = this.buildOrdenation()
-    var items = await model
-      .find(this.filters, this.select)
-      .populate(this.populate)
-      .skip((this.page - 1) * this.limit)
-      .limit(this.limit)
-      .sort(sort)
-      .session(session!)
-      .collation({
-        locale: dbCollation || "pt"
-      }) as []
-
-    return this.result(model, items)
-  }
-
-  private async searchNoPageable(model: mongoose.Model<any>, session?: ClientSession): Promise<SearchResponse<any>> {
-    const sort = this.buildOrdenation()
-    var items = await model
-      .find(this.filters, this.select)
-      .populate(this.populate)
-      .sort(sort)
-      .session(session!)
-      .collation({
-        locale: dbCollation || "pt"
-      }) as []
-
-    return this.result(model, items)
-  }
-
-  private async result(model: mongoose.Model<any>, items: []): Promise<SearchResponse<any>> {
-    var searchResponse: SearchResponse<any> = {}
-    searchResponse.items = items
-
+  public async search(model: mongoose.Model<any>, options: SearchOptions): Promise<SearchResponse<any>> {
     if (this.pageable == true) {
-      var total = await this.count(model)
-      var paging: Pagination = {}
-      paging.total = total
-      paging.page = Number(this.page)
-      paging.limit = Number(this.limit)
-      searchResponse.paging = paging
+      return await this.searchPageable(model, options)
     }
 
-    return searchResponse
+    return await this.searchNoPageable(model, options)
   }
 
   public async count(model: mongoose.Model<any>): Promise<number> {