c2-mongoose 2.1.36 → 2.1.38

package/dist/flow/CrudFlow.d.ts

@@ -16,5 +16,6 @@ declare class CrudFlow<D> {
     get(id: string, pop?: string, sel?: string, session?: ClientSession): Promise<D>;
     getById(id: string, session?: ClientSession): Promise<Partial<D>>;
     sumBy(fieldToSum: any, fieldToGroup: any, addToSet?: any): Promise<any>;
+    sumByAndPaging(fieldToSum: any, fieldToGroup: any, addToSet?: any): Promise<SearchResponse<any>>;
 }
 export default CrudFlow;

package/dist/flow/CrudFlow.js

@@ -179,6 +179,16 @@ var CrudFlow = /** @class */ (function () {
             });
         });
     };
+    CrudFlow.prototype.sumByAndPaging = function (fieldToSum, fieldToGroup, addToSet) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.search.sumByPaging(this.repository, fieldToSum, fieldToGroup, addToSet)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     return CrudFlow;
 }());
 exports.default = CrudFlow;

package/dist/flow/SearchFlow.d.ts

@@ -22,6 +22,7 @@ declare abstract class SearchFlow {
     count(model: mongoose.Model<any>): Promise<number>;
     findOne(repository: mongoose.Model<any>, model: any, params?: any): Promise<any>;
     sumBy(model: mongoose.Model<any>, _sum: any, _by: any, items?: any, session?: ClientSession): Promise<any[]>;
+    sumByPaging(model: mongoose.Model<any>, fieldToSum: any, fieldToGroup: any, items?: any): Promise<SearchResponse<any>>;
     buildDefaultFilters(objectSearch: any): any;
     addFilterModel(model: any, filters: any): void;
 }

package/dist/flow/SearchFlow.js

@@ -241,6 +241,55 @@ var SearchFlow = /** @class */ (function () {
             });
         });
     };
+    SearchFlow.prototype.sumByPaging = function (model, fieldToSum, fieldToGroup, items) {
+        if (items === void 0) { items = undefined; }
+        return __awaiter(this, void 0, void 0, function () {
+            var sort, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        sort = this.buildOrdenation();
+                        return [4 /*yield*/, model.aggregate([
+                                {
+                                    $facet: {
+                                        items: [
+                                            { $match: this.filters },
+                                            {
+                                                $group: {
+                                                    _id: fieldToGroup,
+                                                    totalValue: { "$sum": fieldToSum },
+                                                    count: { "$sum": 1 },
+                                                    items: items
+                                                }
+                                            },
+                                            { $sort: sort },
+                                            { $skip: (this.page - 1) * this.limit },
+                                            { $limit: this.limit }
+                                        ],
+                                        paging: [
+                                            { $match: this.filters },
+                                            { $group: { _id: fieldToGroup, count: { $sum: 1 } } },
+                                            { $count: "total" },
+                                            {
+                                                $addFields: {
+                                                    page: this.page,
+                                                    limit: this.limit
+                                                }
+                                            }
+                                        ]
+                                    }
+                                }
+                            ])];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, {
+                                items: result[0].items,
+                                paging: result[0].paging[0]
+                            }];
+                }
+            });
+        });
+    };
     SearchFlow.prototype.buildDefaultFilters = function (objectSearch) {
         var filters = { $and: [] };
         Object.entries(objectSearch.model).forEach(function (_a) {

package/package.json

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

@@ -68,6 +68,10 @@ class CrudFlow<D> {
     public async sumBy(fieldToSum: any, fieldToGroup: any, addToSet?: any): Promise<any> {
         return await this.search.sumBy(this.repository, fieldToSum, fieldToGroup, addToSet)
     }
+
+    public async sumByAndPaging(fieldToSum: any, fieldToGroup: any, addToSet?: any): Promise<SearchResponse<any>> {
+        return await this.search.sumByPaging(this.repository, fieldToSum, fieldToGroup, addToSet)
+    }
 }
 
 export default CrudFlow

package/src/flow/SearchFlow.ts

@@ -157,6 +157,49 @@ abstract class SearchFlow {
     return ret
   }
 
+  async sumByPaging(model: mongoose.Model<any>, fieldToSum: any, fieldToGroup: any, items: any = undefined): Promise<SearchResponse<any>> {
+    const sort = this.buildOrdenation()
+    const result = await model.aggregate(
+      [
+        {
+          $facet: {
+            items: [
+              { $match: this.filters },
+              {
+                $group: {
+                  _id: fieldToGroup,
+                  totalValue: { "$sum": fieldToSum },
+                  count: { "$sum": 1 },
+                  items: items
+                }
+              },
+              { $sort: sort },
+              { $skip: (this.page - 1) * this.limit },
+              { $limit: this.limit }
+            ],
+            paging: [
+              { $match: this.filters },
+              { $group: { _id: fieldToGroup, count: { $sum: 1 } } },
+              { $count: "total" },
+              {
+                $addFields:
+                {
+                  page: this.page,
+                  limit: this.limit
+                }
+              }
+            ]
+          }
+        }
+      ]
+    )
+
+    return {
+      items: result[0].items,
+      paging: result[0].paging[0]
+    }
+  }
+
   public buildDefaultFilters(objectSearch: any) {
     let filters = { $and: [] } as any
     Object.entries(objectSearch.model).forEach(([key, value]) => {

package/src/types/SearchResponse.d.ts

@@ -1,10 +1,12 @@
-export declare interface SearchResponse<T> {
+declare interface SearchResponse<T> {
     paging?: Pagination,
     items?: T[]
 }
 
-export declare interface Pagination {
+declare interface Pagination {
     total?: number,
     page?: number,
     limit?: number
-}
+}
+
+export { SearchResponse, Pagination }