c2-mongoose 2.1.40 → 2.1.42

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(): Promise<SearchResponse<D>>;
+    find(...pipeline: any): Promise<SearchResponse<D>>;
     getOne(model: D, params?: any): Promise<D>;
     get(id: string, pop?: string, sel?: string, session?: ClientSession): Promise<D>;
     getById(id: string, session?: ClientSession): Promise<Partial<D>>;

package/dist/flow/CrudFlow.js

@@ -124,10 +124,14 @@ var CrudFlow = /** @class */ (function () {
         });
     };
     CrudFlow.prototype.find = function () {
+        var pipeline = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            pipeline[_i] = arguments[_i];
+        }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.search.search(this.repository)];
+                    case 0: return [4 /*yield*/, this.search.search(this.repository, pipeline)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });

package/dist/flow/SearchFlow.d.ts

@@ -9,14 +9,22 @@ declare abstract class SearchFlow {
     select: string;
     populate: any;
     filters: any;
+    sort: any;
     pageable: boolean;
     constructor(params: any);
     buildPopulate(): any;
     buildPath(target: string, nested?: string): any;
     buildOrdenation(): any;
     diacriticSensitiveRegex(string?: string): string;
-    search(model: mongoose.Model<any>): Promise<SearchResponse<any>>;
-    private searchPageable;
+    searchPageable(model: mongoose.Model<any>, ...pipeline: any): Promise<any>;
+    search(model: mongoose.Model<any>, ...pipeline: any): Promise<SearchResponse<any>>;
+    /**
+     *
+     * @param model
+     * @deprecated
+     * @returns
+     */
+    private searchPageableOld;
     private searchNoPageable;
     private result;
     count(model: mongoose.Model<any>): Promise<number>;

package/dist/flow/SearchFlow.js

@@ -56,7 +56,13 @@ var Utils_1 = require("../utils/Utils");
 var SearchFlow = /** @class */ (function () {
     function SearchFlow(params) {
         var _this = this;
-        this.searchPageable = function (model) { return __awaiter(_this, void 0, void 0, function () {
+        /**
+         *
+         * @param model
+         * @deprecated
+         * @returns
+         */
+        this.searchPageableOld = function (model) { return __awaiter(_this, void 0, void 0, function () {
             var sort, items;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -86,6 +92,7 @@ var SearchFlow = /** @class */ (function () {
         this.limit = Number(params.limit || 25);
         this.pageable = params.pageable == false || params.pageable == 'false' ? false : true;
         this.buildPopulate();
+        this.buildOrdenation();
     }
     SearchFlow.prototype.buildPopulate = function () {
         if ((0, Utils_1.isEmpty)(this.populate)) {
@@ -116,6 +123,7 @@ var SearchFlow = /** @class */ (function () {
         var order = {};
         this.orderBy = this.orderBy || "_id";
         order[this.orderBy] = this.order === "desc" ? -1 : 1;
+        this.sort = order;
         return order;
     };
     SearchFlow.prototype.diacriticSensitiveRegex = function (string) {
@@ -128,16 +136,62 @@ var SearchFlow = /** @class */ (function () {
             .replace(/[u|ü|ú|ù|U|Ú|Ü|Ù]/g, '[u,ü,ú,ù,U,Ú,Ü,Ù]')
             .replace(/[ç|Ç|c|C]/g, '[c,C,ç,Ç]');
     };
+    SearchFlow.prototype.searchPageable = function (model) {
+        var pipeline = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            pipeline[_i - 1] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, model.aggregate([
+                            {
+                                $facet: {
+                                    items: [
+                                        { $match: this.filters },
+                                        { $sort: this.sort },
+                                        { $skip: (this.page - 1) * this.limit },
+                                        { $limit: this.limit },
+                                        pipeline
+                                    ],
+                                    paging: [
+                                        { $match: this.filters },
+                                        { $count: "total" },
+                                        {
+                                            $addFields: {
+                                                page: this.page,
+                                                limit: this.limit
+                                            }
+                                        }
+                                    ]
+                                }
+                            }
+                        ])];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result[0]];
+                }
+            });
+        });
+    };
     SearchFlow.prototype.search = function (model) {
+        var pipeline = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            pipeline[_i - 1] = arguments[_i];
+        }
         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*/, 2];
-                        return [4 /*yield*/, this.searchPageable(model)];
+                        if (!(this.pageable == true)) return [3 /*break*/, 4];
+                        if (!pipeline) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.searchPageable(model, pipeline)];
                     case 1: return [2 /*return*/, _a.sent()];
-                    case 2: return [4 /*yield*/, this.searchNoPageable(model)];
+                    case 2: return [4 /*yield*/, this.searchPageableOld(model)];
                     case 3: return [2 /*return*/, _a.sent()];
+                    case 4: return [4 /*yield*/, this.searchNoPageable(model)];
+                    case 5: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -299,6 +353,12 @@ var SearchFlow = /** @class */ (function () {
                 if (['pageable', 'order', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
                     return;
                 }
+                if (value === 'true') {
+                    value = true;
+                }
+                if (value === 'false') {
+                    value = false;
+                }
                 if (key.endsWith('DateRange') || key.endsWith('DateTimeRange')) {
                     var fieldName = key.replace('Range', '');
                     var values = value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.40",
+  "version": "2.1.42",
   "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,8 +44,8 @@ class CrudFlow<D> {
         return dataAfter as D
     }
 
-    public async find(): Promise<SearchResponse<D>> {
-        return await this.search.search(this.repository)
+    public async find(...pipeline: any): Promise<SearchResponse<D>> {
+        return await this.search.search(this.repository, pipeline)
     }
 
     public async getOne(model: D, params: any = {}): Promise<D> {

package/src/flow/SearchFlow.ts

@@ -13,6 +13,7 @@ abstract class SearchFlow {
   select: string
   populate: any
   filters: any
+  sort: any
   pageable: boolean
 
   constructor(params: any) {
@@ -25,6 +26,7 @@ abstract class SearchFlow {
     this.limit = Number(params.limit || 25)
     this.pageable = params.pageable == false || params.pageable == 'false' ? false : true
     this.buildPopulate()
+    this.buildOrdenation()
   }
 
   public buildPopulate(): any {
@@ -58,6 +60,7 @@ abstract class SearchFlow {
     let order = {} as any
     this.orderBy = this.orderBy || "_id"
     order[this.orderBy] = this.order === "desc" ? -1 : 1
+    this.sort = order
     return order
   }
 
@@ -71,15 +74,54 @@ abstract class SearchFlow {
       .replace(/[ç|Ç|c|C]/g, '[c,C,ç,Ç]')
   }
 
-  public async search(model: mongoose.Model<any>): Promise<SearchResponse<any>> {
+  async searchPageable(model: mongoose.Model<any>, ...pipeline: any) {
+    const result = await model.aggregate(
+      [
+        {
+          $facet: {
+            items: [
+              { $match: this.filters },
+              { $sort: this.sort },
+              { $skip: (this.page - 1) * this.limit },
+              { $limit: this.limit },
+              pipeline
+            ],
+            paging: [
+              { $match: this.filters },
+              { $count: "total" },
+              {
+                $addFields:
+                {
+                  page: this.page,
+                  limit: this.limit
+                }
+              }
+            ]
+          }
+        }
+      ]
+    )
+    return result[0]
+  }
+
+  public async search(model: mongoose.Model<any>, ...pipeline: any): Promise<SearchResponse<any>> {
     if (this.pageable == true) {
-      return await this.searchPageable(model)
+      if (pipeline) {
+        return await this.searchPageable(model, pipeline)
+      }
+      return await this.searchPageableOld(model)
     }
 
     return await this.searchNoPageable(model)
   }
 
-  private searchPageable = async (model: mongoose.Model<any>): Promise<SearchResponse<any>> => {
+  /**
+   * 
+   * @param model
+   * @deprecated
+   * @returns 
+   */
+  private searchPageableOld = async (model: mongoose.Model<any>): Promise<SearchResponse<any>> => {
     const sort = this.buildOrdenation()
     var items = await model
       .find(this.filters, this.select)
@@ -209,6 +251,14 @@ abstract class SearchFlow {
           return
         }
 
+        if (value === 'true') {
+          value = true
+        }
+
+        if (value === 'false') {
+          value = false
+        }
+
         if (key.endsWith('DateRange') || key.endsWith('DateTimeRange')) {
           var fieldName = key.replace('Range', '')
           var values = value as any