c2-mongoose 2.1.370 → 2.1.372

package/dist/flow/searcher/v3/item/LookupManyToOneFlowItem.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/LookupManyToOneFlowItem.js

@@ -0,0 +1,120 @@
+"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 = [];
+        try {
+            populateClauseLookup.push({
+                $unwind: "$".concat(previousPath)
+            });
+            //init code here
+            var currentField_1 = remainingPath[0], othersFields = remainingPath.slice(1);
+            if (!currentField_1) {
+                return [];
+            }
+            var currentFieldDefinition = GetFieldDefinitionFlowItem_1.default.execute(model, "".concat(previousPath, ".").concat(currentField_1));
+            if (!currentFieldDefinition || !currentFieldDefinition.options || !currentFieldDefinition.options.ref) {
+                throw new Error("[1]No reference found for populate field: ".concat([previousPath, currentField_1]));
+            }
+            var currentType = currentFieldDefinition.instance;
+            if (currentType === 'Array' && !(othersFields === null || othersFields === void 0 ? void 0 : othersFields.length))
+                return [];
+            var modelName = currentFieldDefinition.options.ref;
+            var currentModel = global.connectionMongoose.model(modelName);
+            var collectionName = currentModel.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_1); })) {
+                populateClauseLookup.push({
+                    $lookup: {
+                        from: collectionName,
+                        localField: "".concat(previousPath, ".").concat(currentField_1),
+                        foreignField: "_id",
+                        as: "".concat(previousPath, ".").concat(currentField_1)
+                    }
+                });
+                populateClauseLookup.push({
+                    $unwind: {
+                        path: "$".concat(previousPath, ".").concat(currentField_1),
+                        preserveNullAndEmptyArrays: 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)] = "$".concat(previousPath), _b)]
+                    }
+                }
+            });
+            var _loop_1 = function () {
+                var _c;
+                var nextField = othersFields[0], rest = othersFields.slice(1);
+                var nextDefinition = GetFieldDefinitionFlowItem_1.default.execute(currentModel, nextField);
+                if (!nextDefinition || !nextDefinition.options || !nextDefinition.options.ref) {
+                    throw new Error("[1]No reference found for populate field: ".concat([previousPath, currentField_1]));
+                }
+                var nextType = nextDefinition.instance;
+                if (nextType === 'Array' && !(othersFields === null || othersFields === void 0 ? void 0 : othersFields.length))
+                    return "continue";
+                var nextModelName = nextDefinition.options.ref;
+                var nextRefModel = global.connectionMongoose.model(nextModelName);
+                var collectionName_1 = nextRefModel.collection.name;
+                if (!__spreadArray(__spreadArray([], populateClauses, true), populateClauseLookup, true).some(function (populateClause) { var _a; return ((_a = populateClause === null || populateClause === void 0 ? void 0 : populateClause.$lookup) === null || _a === void 0 ? void 0 : _a.localField) === nextField; })) {
+                    var populateClauseLookup_1 = [
+                        {
+                            $lookup: {
+                                from: collectionName_1,
+                                localField: nextField,
+                                foreignField: "_id",
+                                as: nextField
+                            }
+                        },
+                    ];
+                    if (nextType !== 'Array') {
+                        populateClauseLookup_1.push({
+                            $addFields: (_c = {},
+                                _c["".concat(nextField)] = { $ifNull: [{ $arrayElemAt: ["$".concat(nextField), 0] }, undefined] },
+                                _c)
+                        });
+                    }
+                }
+            };
+            while (othersFields === null || othersFields === void 0 ? void 0 : othersFields.length) {
+                _loop_1();
+            }
+            populateClauseLookup = __spreadArray(__spreadArray([], populateClauseLookup, true), this.execute("".concat(previousPath, ".").concat(currentField_1), othersFields, __spreadArray(__spreadArray([], populateClauses, true), populateClauseLookup, true), currentModel), true);
+            return __spreadArray([], populateClauseLookup, true);
+        }
+        catch (error) {
+            console.error(error.message);
+            return [];
+        }
+    };
+    return LookupArrayFlowItem;
+}());
+exports.default = new LookupArrayFlowItem;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.370",
+  "version": "2.1.372",
   "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/LookupManyToOneFlowItem.ts

@@ -0,0 +1,119 @@
+import mongoose from "mongoose";
+import GetFieldDefinitionFlowItem from "./GetFieldDefinitionFlowItem";
+
+class LookupArrayFlowItem {
+  execute(previousPath: string, remainingPath: string[], populateClauses: any[], model: mongoose.Model<any>): any[] {
+
+    let populateClauseLookup = []
+
+    try {
+      populateClauseLookup.push({
+        $unwind: `$${previousPath}`
+      });
+
+
+      //init code here
+      let [currentField, ...othersFields] = remainingPath
+
+      if (!currentField) {
+        return []
+      }
+
+      let currentFieldDefinition = GetFieldDefinitionFlowItem.execute(model, `${previousPath}.${currentField}`);
+      if (!currentFieldDefinition || !currentFieldDefinition.options || !currentFieldDefinition.options.ref) {
+        throw new Error(`[1]No reference found for populate field: ${[previousPath, currentField]}`);
+      }
+
+
+      let currentType = currentFieldDefinition.instance
+      if (currentType === 'Array' && !othersFields?.length) return []
+
+      let modelName = currentFieldDefinition.options.ref;
+      let currentModel = (global as any).connectionMongoose.model(modelName);
+      let collectionName = currentModel.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
+          }
+        })
+      }
+
+      //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}`]: `$${previousPath}` }]
+          }
+        }
+      });
+
+
+      while (othersFields?.length) {
+
+        let [nextField, ...rest] = othersFields
+        let nextDefinition = GetFieldDefinitionFlowItem.execute(currentModel, nextField);
+
+        if (!nextDefinition || !nextDefinition.options || !nextDefinition.options.ref) {
+          throw new Error(`[1]No reference found for populate field: ${[previousPath, currentField]}`);
+        }
+        let nextType = nextDefinition.instance
+        if (nextType === 'Array' && !othersFields?.length) continue;
+
+        let nextModelName = nextDefinition.options.ref;
+        let nextRefModel = (global as any).connectionMongoose.model(nextModelName);
+        let collectionName = nextRefModel.collection.name;
+
+        if (![...populateClauses, ...populateClauseLookup].some((populateClause: any) => populateClause?.$lookup?.localField === nextField)) {
+          const populateClauseLookup: any[] = [
+            {
+              $lookup: {
+                from: collectionName, // The collection where user data is stored
+                localField: nextField,
+                foreignField: "_id",
+                as: nextField
+              }
+            },
+          ]
+          if (nextType !== 'Array') {
+            populateClauseLookup.push(
+              {
+                $addFields: {
+                  [`${nextField}`]: { $ifNull: [{ $arrayElemAt: [`$${nextField}`, 0] }, undefined] },
+                }
+              }
+            )
+          }
+        }
+      }
+
+      populateClauseLookup = [...populateClauseLookup, ...this.execute(`${previousPath}.${currentField}`, othersFields, [...populateClauses, ...populateClauseLookup], currentModel)]
+
+      return [...populateClauseLookup]
+    } catch (error: any) {
+      console.error(error.message)
+      return []
+    }
+  }
+}
+
+export default new LookupArrayFlowItem