c2-mongoose 2.1.364 → 2.1.366

package/dist/flow/searcher/v3/item/LookupArrayFlowItem.d.ts

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class LookupArrayFlowItem {
+    execute(previousPath: string, remainingPath: string[], populateClauses: any[], model: mongoose.Model<any>): any[];
+}
+declare const _default: LookupArrayFlowItem;
+export default _default;

package/dist/flow/searcher/v3/item/LookupArrayFlowItem.js

@@ -0,0 +1,78 @@
+"use strict";
+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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var GetFieldDefinitionFlowItem_1 = __importDefault(require("./GetFieldDefinitionFlowItem"));
+var LookupArrayFlowItem = /** @class */ (function () {
+    function LookupArrayFlowItem() {
+    }
+    LookupArrayFlowItem.prototype.execute = function (previousPath, remainingPath, populateClauses, model) {
+        var _a, _b;
+        var populateClauseLookup = [];
+        populateClauseLookup.push({
+            $unwind: "$".concat(previousPath)
+        });
+        //init code here
+        var currentField = remainingPath[0], others = remainingPath.slice(1);
+        if (!currentField) {
+            return [];
+        }
+        var currentFieldDefinition = GetFieldDefinitionFlowItem_1.default.execute(model, currentField);
+        if (!currentFieldDefinition || !currentFieldDefinition.options || !currentFieldDefinition.options.ref) {
+            throw new Error("[1]No reference found for populate field: ".concat([previousPath, currentField]));
+        }
+        var typeFirst = currentFieldDefinition.instance;
+        if (typeFirst === 'Array' && !(others === null || others === void 0 ? void 0 : others.length))
+            return [];
+        var modelName = currentFieldDefinition.options.ref;
+        var refModel = global.connectionMongoose.model(modelName);
+        var collectionName = refModel.collection.name;
+        if (!populateClauses.some(function (populateClause) { var _a; return ((_a = populateClause === null || populateClause === void 0 ? void 0 : populateClause.$lookup) === null || _a === void 0 ? void 0 : _a.localField) === "".concat(previousPath, ".").concat(currentField); })) {
+            populateClauseLookup.push({
+                $lookup: {
+                    from: collectionName,
+                    localField: "".concat(previousPath, ".").concat(currentField),
+                    foreignField: "_id",
+                    as: "".concat(previousPath, ".").concat(currentField)
+                }
+            });
+            populateClauseLookup.push({
+                $unwind: {
+                    path: "$".concat(previousPath, ".").concat(currentField),
+                    preserveNullAndEmptyArrays: true
+                }
+            });
+            populateClauses = __spreadArray(__spreadArray([], populateClauses, true), populateClauseLookup, true);
+        }
+        //end code here
+        populateClauseLookup.push({
+            $group: (_a = {
+                    _id: "$_id",
+                    doc: { $first: "$$ROOT" }
+                },
+                _a["".concat(previousPath)] = { $push: "$".concat(previousPath) } // agrupa apenas o array
+            ,
+                _a)
+        });
+        populateClauseLookup.push({
+            $replaceRoot: {
+                newRoot: {
+                    $mergeObjects: ["$doc", (_b = {}, _b["".concat(previousPath)] = { $push: "$".concat(previousPath) }, _b)]
+                }
+            }
+        });
+        return populateClauses;
+    };
+    return LookupArrayFlowItem;
+}());
+exports.default = new LookupArrayFlowItem;

package/dist/flow/searcher/v3/item/PopulateFlowItem.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var GetFieldDefinitionFlowItem_1 = __importDefault(require("./GetFieldDefinitionFlowItem"));
+var LookupArrayFlowItem_1 = __importDefault(require("./LookupArrayFlowItem"));
 var PopulateFlowItem = /** @class */ (function () {
     function PopulateFlowItem() {
     }
@@ -27,6 +28,10 @@ var PopulateFlowItem = /** @class */ (function () {
             if (!fieldDefinition)
                 return;
             var typeFirst = fieldDefinition.instance;
+            if (typeFirst === 'Array') {
+                LookupArrayFlowItem_1.default.execute(first, rest, populateClauses, modelRoot);
+                return;
+            }
             while ((typeFirst === 'Array' || typeFirst === 'Embedded') && (rest === null || rest === void 0 ? void 0 : rest.length)) {
                 first = [first, rest[0]].join(".");
                 rest.splice(0, 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.364",
+  "version": "2.1.366",
   "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/searcher/v3/item/LookupArrayFlowItem.ts

@@ -0,0 +1,74 @@
+import mongoose from "mongoose";
+import GetFieldDefinitionFlowItem from "./GetFieldDefinitionFlowItem";
+
+class LookupArrayFlowItem {
+  execute(previousPath: string, remainingPath: string[], populateClauses: any[], model: mongoose.Model<any>): any[] {
+
+    const populateClauseLookup = []
+    populateClauseLookup.push({
+      $unwind: `$${previousPath}`
+    });
+
+
+    //init code here
+    let [currentField, ...others] = remainingPath
+
+    if (!currentField) {
+      return []
+    }
+
+    let currentFieldDefinition = GetFieldDefinitionFlowItem.execute(model, currentField);
+    if (!currentFieldDefinition || !currentFieldDefinition.options || !currentFieldDefinition.options.ref) {
+      throw new Error(`[1]No reference found for populate field: ${[previousPath, currentField]}`);
+    }
+
+
+    let typeFirst = currentFieldDefinition.instance
+    if (typeFirst === 'Array' && !others?.length) return []
+
+    let modelName = currentFieldDefinition.options.ref;
+    let refModel = (global as any).connectionMongoose.model(modelName);
+    let collectionName = refModel.collection.name;
+
+
+    if (!populateClauses.some((populateClause: any) => populateClause?.$lookup?.localField === `${previousPath}.${currentField}`)) {
+      populateClauseLookup.push({
+        $lookup: {
+          from: collectionName, // The collection where user data is stored
+          localField: `${previousPath}.${currentField}`,
+          foreignField: "_id",
+          as: `${previousPath}.${currentField}`
+        }
+      })
+
+      populateClauseLookup.push({
+        $unwind: {
+          path: `$${previousPath}.${currentField}`,
+          preserveNullAndEmptyArrays: true
+        }
+      })
+
+      populateClauses = [...populateClauses, ...populateClauseLookup]
+    }
+
+    //end code here
+    populateClauseLookup.push({
+      $group: {
+        _id: "$_id",
+        doc: { $first: "$$ROOT" }, // pega o documento inteiro
+        [`${previousPath}`]: { $push: `$${previousPath}` } // agrupa apenas o array
+      }
+    });
+    populateClauseLookup.push({
+      $replaceRoot: {
+        newRoot: {
+          $mergeObjects: ["$doc", { [`${previousPath}`]: { $push: `$${previousPath}` } }]
+        }
+      }
+    });
+
+    return populateClauses
+  }
+}
+
+export default new LookupArrayFlowItem

package/src/flow/searcher/v3/item/PopulateFlowItem.ts

@@ -1,5 +1,6 @@
 import mongoose from "mongoose";
 import GetFieldDefinitionFlowItem from "./GetFieldDefinitionFlowItem"
+import LookupArrayFlowItem from "./LookupArrayFlowItem";
 
 class PopulateFlowItem {
   execute(populates: string = "", modelRoot: mongoose.Model<any>): any[] {
@@ -16,6 +17,11 @@ class PopulateFlowItem {
 
       let typeFirst = fieldDefinition.instance
 
+      if (typeFirst === 'Array') {
+        LookupArrayFlowItem.execute(first, rest, populateClauses, modelRoot)
+        return
+      }
+
       while ((typeFirst === 'Array' || typeFirst === 'Embedded') && rest?.length) {
         first = [first, rest[0]].join(".")
         rest.splice(0, 1)