c2-mongoose 2.1.45 → 2.1.47

package/dist/flow/CrudFlow.d.ts

@@ -1,6 +1,9 @@
 import mongoose, { ClientSession } from "mongoose";
 import { SearchResponse } from "../types/SearchResponse";
 import SearchFlow from "./SearchFlow";
+export interface PipelineStage {
+    [key: string]: any;
+}
 declare class CrudFlow<D> {
     private repository;
     private search;
@@ -12,7 +15,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(...pipeline: any): Promise<SearchResponse<D>>;
+    find(...pipelineStages: PipelineStage[]): 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,14 +124,14 @@ var CrudFlow = /** @class */ (function () {
         });
     };
     CrudFlow.prototype.find = function () {
-        var pipeline = [];
+        var pipelineStages = [];
         for (var _i = 0; _i < arguments.length; _i++) {
-            pipeline[_i] = arguments[_i];
+            pipelineStages[_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, pipeline)];
+                    case 0: return [4 /*yield*/, this.search.search(this.repository, pipelineStages)];
                     case 1: return [2 /*return*/, _a.sent()];
                 }
             });

package/dist/flow/SearchFlow.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 };
 };
@@ -138,32 +147,33 @@ var SearchFlow = /** @class */ (function () {
     };
     SearchFlow.prototype.searchPageable = function (model, pipeline) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
+            var stagesItems, 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 0:
+                        stagesItems = __spreadArray([
+                            { $match: this.filters },
+                            { $sort: this.sort },
+                            { $skip: (this.page - 1) * this.limit },
+                            { $limit: this.limit }
+                        ], pipeline, true);
+                        return [4 /*yield*/, model.aggregate([
+                                {
+                                    $facet: {
+                                        items: stagesItems,
+                                        paging: [
+                                            { $match: this.filters },
+                                            { $count: "total" },
+                                            {
+                                                $addFields: {
+                                                    page: this.page,
+                                                    limit: this.limit
+                                                }
                                             }
-                                        }
-                                    ]
+                                        ]
+                                    }
                                 }
-                            }
-                        ])];
+                            ])];
                     case 1:
                         result = _a.sent();
                         return [2 /*return*/, result[0]];

package/package.json

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

@@ -3,6 +3,9 @@ import { SearchResponse } from "../types/SearchResponse"
 import SearchFlow from "./SearchFlow"
 import { isEmpty, isNotEmpty } from "../utils/Utils"
 
+export interface PipelineStage {
+    [key: string]: any;
+}
 class CrudFlow<D> {
 
     private repository: mongoose.Model<any>
@@ -44,8 +47,8 @@ class CrudFlow<D> {
         return dataAfter as D
     }
 
-    public async find(...pipeline: any): Promise<SearchResponse<D>> {
-        return await this.search.search(this.repository, pipeline)
+    public async find(...pipelineStages: PipelineStage[]): Promise<SearchResponse<D>> {
+        return await this.search.search(this.repository, pipelineStages)
     }
 
     public async getOne(model: D, params: any = {}): Promise<D> {

package/src/flow/SearchFlow.ts

@@ -75,17 +75,19 @@ abstract class SearchFlow {
   }
 
   async searchPageable(model: mongoose.Model<any>, pipeline: any) {
+    let stagesItems = [
+      { $match: this.filters },
+      { $sort: this.sort },
+      { $skip: (this.page - 1) * this.limit },
+      { $limit: this.limit },
+      ...pipeline
+    ]
+
     const result = await model.aggregate(
       [
         {
           $facet: {
-            items: [
-              { $match: this.filters },
-              { $sort: this.sort },
-              { $skip: (this.page - 1) * this.limit },
-              { $limit: this.limit },
-              pipeline
-            ],
+            items: stagesItems,
             paging: [
               { $match: this.filters },
               { $count: "total" },