c2-mongoose 2.1.320 → 2.1.321

package/dist/flow/searcher/SearcherV2Flow.d.ts

@@ -0,0 +1,10 @@
+import mongoose from "mongoose";
+export interface IParams {
+    [key: string]: any;
+    mainFilter: any;
+}
+declare class SearcherV2Flow {
+    exec(params: IParams, model: mongoose.Model<any>): Promise<any>;
+}
+declare const _default: SearcherV2Flow;
+export default _default;

package/dist/flow/searcher/SearcherV2Flow.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var GroupFlowItem_1 = __importDefault(require("./item/GroupFlowItem"));
+var PopulateFlowItem_1 = __importDefault(require("./item/PopulateFlowItem"));
+var SortFlowItem_1 = __importDefault(require("./item/SortFlowItem"));
+var ProjectFlowItem_1 = __importDefault(require("./item/ProjectFlowItem"));
+var MatchFlowItem_1 = __importDefault(require("./item/MatchFlowItem"));
+var BuildPaginationDataFlowItem_1 = __importDefault(require("./item/BuildPaginationDataFlowItem"));
+var SearcherV2Flow = /** @class */ (function () {
+    function SearcherV2Flow() {
+    }
+    SearcherV2Flow.prototype.exec = function (params, model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var facet, pipelineFacetPaging, pipelineFacetItems, result, ret;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        facet = {};
+                        pipelineFacetPaging = [];
+                        pipelineFacetItems = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], GroupFlowItem_1.default.exec(params.groupBy, params.sumFields, params.groupDetailed, model), true), PopulateFlowItem_1.default.exec(params.populate, model), true), MatchFlowItem_1.default.exec(params, model), true), SortFlowItem_1.default.exec(params.orderBy, params.orderSense), true), ProjectFlowItem_1.default.exec(params.select), true);
+                        if (params.pageable) {
+                            pipelineFacetItems = __spreadArray(__spreadArray([], pipelineFacetItems, true), [
+                                { $skip: ((params.page - 1) * params.limit) },
+                                { $limit: params.limit }
+                            ], false);
+                            pipelineFacetPaging = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], GroupFlowItem_1.default.exec(params.groupBy, params.sumFields, params.groupDetailed, model), true), PopulateFlowItem_1.default.exec(params.populate, model), true), MatchFlowItem_1.default.exec(params, model), true), BuildPaginationDataFlowItem_1.default.exec(params.page, params.limit), true);
+                            facet.paging = pipelineFacetPaging;
+                        }
+                        facet.items = pipelineFacetItems;
+                        return [4 /*yield*/, model.aggregate([
+                                {
+                                    $match: MatchFlowItem_1.default.exec(params.mainFilter, model)
+                                },
+                                {
+                                    $facet: facet
+                                }
+                            ])];
+                    case 1:
+                        result = _a.sent();
+                        ret = {};
+                        ret.items = result[0].items;
+                        if (params.pageable) {
+                            ret.paging = result[0].paging[0];
+                        }
+                        return [2 /*return*/, ret];
+                }
+            });
+        });
+    };
+    return SearcherV2Flow;
+}());
+exports.default = new SearcherV2Flow;

package/dist/flow/searcher/item/BuildConditionFlowItem.d.ts

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class BuildConditionFlowItem {
+    exec(key: string, value: any, model: mongoose.Model<any>): any;
+}
+declare const _default: BuildConditionFlowItem;
+export default _default;

package/dist/flow/searcher/item/BuildConditionFlowItem.js

@@ -0,0 +1,130 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var moment_1 = __importDefault(require("moment"));
+var mongoose_1 = require("mongoose");
+var BuildRegexFlowItem_1 = __importDefault(require("./BuildRegexFlowItem"));
+var IsValidObjectIdFlowItem_1 = __importDefault(require("./IsValidObjectIdFlowItem"));
+var BuildConditionFlowItem = /** @class */ (function () {
+    function BuildConditionFlowItem() {
+    }
+    BuildConditionFlowItem.prototype.exec = function (key, value, model) {
+        var _a;
+        var _b, _c;
+        var condition = {};
+        if (key.endsWith('DateRange')) {
+            var fieldName = key.replace('Range', '');
+            var values = value;
+            if (values[0]) {
+                var momentValue = (0, moment_1.default)(values[0]);
+                momentValue.hour(0);
+                momentValue.minute(0);
+                momentValue.second(0);
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $gte: momentValue.tz('America/Sao_Paulo', false).toDate() });
+            }
+            if (values[1]) {
+                var momentValue = (0, moment_1.default)(values[1]);
+                momentValue.hour(23);
+                momentValue.minute(59);
+                momentValue.second(59);
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $lte: momentValue.tz('America/Sao_Paulo', false).toDate() });
+            }
+        }
+        else if (key.endsWith('DateTimeRange')) {
+            var fieldName = key.replace('Range', '');
+            var values = value;
+            if (values[0]) {
+                var momentValue = (0, moment_1.default)(values[0]);
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $gte: momentValue.tz('America/Sao_Paulo', false).toDate() });
+            }
+            if (values[1]) {
+                var momentValue = (0, moment_1.default)(values[1]);
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $lte: momentValue.tz('America/Sao_Paulo', false).toDate() });
+            }
+        }
+        else if (key.endsWith('Range')) {
+            var fieldName = key.replace('Range', '');
+            var values = value;
+            if (values[0]) {
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $gte: Number(values[0]) });
+            }
+            if (values[1]) {
+                condition[fieldName] = __assign(__assign({}, condition[fieldName]), { $lte: Number(values[1]) });
+            }
+        }
+        else if (key.endsWith('Like')) {
+            var fieldName = key.replace('Like', '');
+            condition[fieldName] = BuildRegexFlowItem_1.default.exec(value); //{ $regex: value as any, $options: 'i' }
+        }
+        else if (key.endsWith("AtLeastOneExists")) {
+            key = key.replace("AtLeastOneExists", "");
+            var fields = key.split('.');
+            if (!fields)
+                return condition;
+            condition[fields[0]] = { $elemMatch: (_a = {}, _a[fields[1]] = { $exists: value }, _a) };
+        }
+        else if (key.endsWith('Exists')) {
+            var fieldName = key.replace('Exists', '');
+            condition[fieldName] = { $exists: value };
+        }
+        else if (key.endsWith("IsEmpty")) {
+            key = key.replace("IsEmpty", "");
+            condition[key] = value ? { $size: 0 } : { $not: { $size: 0 } };
+        }
+        else {
+            if (((_c = (_b = model === null || model === void 0 ? void 0 : model.schema) === null || _b === void 0 ? void 0 : _b.paths[key]) === null || _c === void 0 ? void 0 : _c.instance) === 'Array') {
+                if (!Array.isArray(value)) {
+                    value = [value];
+                }
+                value === null || value === void 0 ? void 0 : value.forEach(function (v) {
+                    if (typeof v === 'string' && IsValidObjectIdFlowItem_1.default.exec(v)) {
+                        v = new mongoose_1.Types.ObjectId(v);
+                    }
+                });
+                if (key.endsWith("NotIn")) {
+                    key = key.replace("NotIn", "");
+                    condition[key] = { $nin: value };
+                }
+                else {
+                    condition[key] = { $in: value };
+                }
+            }
+            else if (Array.isArray(value)) {
+                var arr = [];
+                for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+                    var val = value_1[_i];
+                    if (typeof val === 'string' && IsValidObjectIdFlowItem_1.default.exec(val)) {
+                        val = new mongoose_1.Types.ObjectId(val);
+                    }
+                    arr.push(val);
+                }
+                if (key.endsWith("NotIn")) {
+                    key = key.replace("NotIn", "");
+                    condition[key] = { $nin: arr };
+                }
+                else {
+                    condition[key] = { $in: arr };
+                }
+            }
+            else {
+                condition[key] = value;
+            }
+        }
+        return condition;
+    };
+    return BuildConditionFlowItem;
+}());
+exports.default = new BuildConditionFlowItem;

package/dist/flow/searcher/item/BuildPaginationDataFlowItem.d.ts

@@ -0,0 +1,5 @@
+declare class BuildPaginationDataFlowItem {
+    exec(page: number, limit: number): any[];
+}
+declare const _default: BuildPaginationDataFlowItem;
+export default _default;

package/dist/flow/searcher/item/BuildPaginationDataFlowItem.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BuildPaginationDataFlowItem = /** @class */ (function () {
+    function BuildPaginationDataFlowItem() {
+    }
+    BuildPaginationDataFlowItem.prototype.exec = function (page, limit) {
+        return [
+            { $count: "total" },
+            {
+                $addFields: {
+                    page: page,
+                    limit: limit,
+                    total: "$total",
+                    totalPages: {
+                        $cond: {
+                            if: { $eq: ['$total', 0] },
+                            then: 0,
+                            else: { $ceil: { $divide: ['$total', limit] } }
+                        }
+                    },
+                    startIndex: { $subtract: [{ $multiply: [page, limit] }, limit - 1] },
+                    endIndex: {
+                        $cond: {
+                            if: { $gt: [{ $multiply: [page, limit] }, "$total"] },
+                            then: "$total",
+                            else: { $multiply: [page, limit] }
+                        }
+                    }
+                }
+            }
+        ];
+    };
+    return BuildPaginationDataFlowItem;
+}());
+exports.default = new BuildPaginationDataFlowItem;

package/dist/flow/searcher/item/BuildRegexFlowItem.d.ts

@@ -0,0 +1,5 @@
+declare class BuildRegexFlowItem {
+    exec(searchText: string): RegExp;
+}
+declare const _default: BuildRegexFlowItem;
+export default _default;

package/dist/flow/searcher/item/BuildRegexFlowItem.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var BuildRegexFlowItem = /** @class */ (function () {
+    function BuildRegexFlowItem() {
+    }
+    BuildRegexFlowItem.prototype.exec = function (searchText) {
+        var regexExpression = searchText
+            .replace(/[+?^${}()|[\]\\]/g, '\\$&') //Tratar os caracteres que podem ser chaves, escape os demais q podem ser regex
+            .replace(/^"/, '^').replace(/"$/, '$') //Replace aspas duplas para busca exata
+            .replace(/^%22/, '^').replace(/%22$/, '$') //Replace aspas duplas para busca exata
+            .replace(/%20/, ' ') //Replace espaço em branco para nao quebrar o proximo replace
+            .replace(/\*/g, '.*?') //Replace % para o padrão regex (% é muito utilizado como o .*? e é mais simples para o usuario digitar)
+            .replace(/%/g, '.*?') //Replace % para o padrão regex (% é muito utilizado como o .*? e é mais simples para o usuario digitar)
+            .replace(/[ç|Ç|c|C]/g, '[c,C,ç,Ç]')
+            .replace(/[a|á|à|ä|â|A|Á|Â|Ã|Ä]/g, '[a,á,à,ä,â,A,Á,Â,Ã,Ä]')
+            .replace(/[e|é|ë|è|E|É|Ë|È]/g, '[e,é,ë,è,E,É,Ë,È]')
+            .replace(/[i|í|ï|ì|I|Í|Ï|Ì]/g, '[i,í,ï,ì,I,Í,Ï,Ì]')
+            .replace(/[o|ó|ö|ò|õ|O|Ó|Ö|Ô|Õ]/g, '[o,ó,ö,ò,õ,O,Ó,Ö,Ô,Õ]')
+            .replace(/[u|ü|ú|ù|U|Ú|Ü|Ù]/g, '[u,ü,ú,ù,U,Ú,Ü,Ù]');
+        return new RegExp("".concat(regexExpression), 'i');
+    };
+    return BuildRegexFlowItem;
+}());
+exports.default = new BuildRegexFlowItem;

package/dist/flow/searcher/item/ExtractFieldsOfTypeFlowItem.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from "mongoose";
+declare class ExtractFieldsOfTypeFlowItem {
+    exec(schema: Schema, typing?: string, parent?: string): string[];
+}
+declare const _default: ExtractFieldsOfTypeFlowItem;
+export default _default;

package/dist/flow/searcher/item/ExtractFieldsOfTypeFlowItem.js

@@ -0,0 +1,32 @@
+"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));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var ExtractFieldsOfTypeFlowItem = /** @class */ (function () {
+    function ExtractFieldsOfTypeFlowItem() {
+    }
+    ExtractFieldsOfTypeFlowItem.prototype.exec = function (schema, typing, parent) {
+        var _this = this;
+        if (typing === void 0) { typing = 'String'; }
+        if (parent === void 0) { parent = ''; }
+        var fieldsTyped = [];
+        Object.keys(schema.paths).forEach(function (field) {
+            if (schema.paths[field].instance === typing) {
+                fieldsTyped.push("".concat(parent !== '' ? "".concat(parent, ".") : '').concat(field));
+            }
+            else if (schema.paths[field].instance === 'Embedded') {
+                fieldsTyped = __spreadArray(__spreadArray([], fieldsTyped, true), _this.exec(schema.paths[field].schema, typing, field), true);
+            }
+        });
+        return fieldsTyped;
+    };
+    return ExtractFieldsOfTypeFlowItem;
+}());
+exports.default = new ExtractFieldsOfTypeFlowItem;

package/dist/flow/searcher/item/GetTypeOfFieldInModelFlowItem.d.ts

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class GetTypeOfFieldInModelFlowItem {
+    exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string;
+}
+declare const _default: GetTypeOfFieldInModelFlowItem;
+export default _default;

package/dist/flow/searcher/item/GetTypeOfFieldInModelFlowItem.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var GetTypeOfFieldInModelFlowItem = /** @class */ (function () {
+    function GetTypeOfFieldInModelFlowItem() {
+    }
+    GetTypeOfFieldInModelFlowItem.prototype.exec = function (fieldToGroup, modelRoot) {
+        var fieldDefinition = modelRoot.schema.path(fieldToGroup);
+        return fieldDefinition.instance;
+    };
+    return GetTypeOfFieldInModelFlowItem;
+}());
+exports.default = new GetTypeOfFieldInModelFlowItem;

package/dist/flow/searcher/item/GroupFlowItem.d.ts

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class GroupFlowItem {
+    exec(fieldToGroup: string, sumFields: string, detailed: boolean, modelRoot: mongoose.Model<any>): any[];
+}
+declare const _default: GroupFlowItem;
+export default _default;

package/dist/flow/searcher/item/GroupFlowItem.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var GetTypeOfFieldInModelFlowItem_1 = __importDefault(require("./GetTypeOfFieldInModelFlowItem"));
+var GroupFlowItem = /** @class */ (function () {
+    function GroupFlowItem() {
+    }
+    GroupFlowItem.prototype.exec = function (fieldToGroup, sumFields, detailed, modelRoot) {
+        var _a;
+        if (!fieldToGroup)
+            return [];
+        var sumField = sumFields ? sumFields[0] : undefined;
+        var groupsClauses = [];
+        var first = fieldToGroup.split('.')[0];
+        var typeOfFieldToGroup = GetTypeOfFieldInModelFlowItem_1.default.exec(first, modelRoot);
+        if (typeOfFieldToGroup === "Array") {
+            groupsClauses.push({
+                $unwind: {
+                    path: "$".concat(first),
+                    preserveNullAndEmptyArrays: true,
+                }
+            });
+        }
+        var groupField = "$".concat(fieldToGroup);
+        // Check if the field ends with "Date" and add day precision
+        if (fieldToGroup.endsWith("Date") || fieldToGroup.endsWith("DateTime")) {
+            groupField = {
+                $dateToString: {
+                    format: "%Y-%m-%d",
+                    date: "$".concat(fieldToGroup)
+                }
+            };
+        }
+        var groupClause = {
+            $group: {
+                _id: groupField,
+                count: { $sum: 1 }
+            }
+        };
+        if (detailed) {
+            groupClause.$group.docs = { $push: "$$ROOT" };
+        }
+        if (sumField) {
+            var tempFieldName = sumField.replace(/\./g, '_');
+            var firstSumField = sumField.split('.')[0];
+            var typeOfFieldToSum = GetTypeOfFieldInModelFlowItem_1.default.exec(firstSumField, modelRoot);
+            if (typeOfFieldToSum === "Array") {
+                groupClause.$group[tempFieldName] = { $sum: { $sum: { '$ifNull': ["$".concat(sumField), 0] } } };
+            }
+            else {
+                groupClause.$group[tempFieldName] = { $sum: { $ifNull: ["$".concat(sumField), 0] } };
+            }
+            groupsClauses.push(groupClause);
+        }
+        else {
+            groupsClauses.push(groupClause);
+        }
+        var projectClause = {
+            $project: (_a = {
+                    _id: 1
+                },
+                _a[fieldToGroup] = "$_id",
+                _a.count = 1,
+                _a)
+        };
+        if (detailed) {
+            projectClause.$project.docs = 1;
+        }
+        if (sumField) {
+            var tempFieldName = sumField.replace(/\./g, '_');
+            projectClause.$project["".concat(sumField, "Total")] = "$".concat(tempFieldName);
+        }
+        groupsClauses.push(projectClause);
+        return groupsClauses;
+    };
+    return GroupFlowItem;
+}());
+exports.default = new GroupFlowItem;

package/dist/flow/searcher/item/IsValidObjectIdFlowItem.d.ts

@@ -0,0 +1,5 @@
+declare class IsValidObjectIdFlowItem {
+    exec(value: string): boolean;
+}
+declare const _default: IsValidObjectIdFlowItem;
+export default _default;

package/dist/flow/searcher/item/IsValidObjectIdFlowItem.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var IsValidObjectIdFlowItem = /** @class */ (function () {
+    function IsValidObjectIdFlowItem() {
+    }
+    IsValidObjectIdFlowItem.prototype.exec = function (value) {
+        var objectIdPattern = /^[0-9a-fA-F]{24}$/;
+        return objectIdPattern.test(value);
+    };
+    return IsValidObjectIdFlowItem;
+}());
+exports.default = new IsValidObjectIdFlowItem;

package/dist/flow/searcher/item/MatchFlowItem.d.ts

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class MatchFlowItem {
+    exec(filters: any, model: mongoose.Model<any>): any;
+}
+declare const _default: MatchFlowItem;
+export default _default;

package/dist/flow/searcher/item/MatchFlowItem.js

@@ -0,0 +1,132 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 mongoose_1 = require("mongoose");
+var ExtractFieldsOfTypeFlowItem_1 = __importDefault(require("./ExtractFieldsOfTypeFlowItem"));
+var IsValidObjectIdFlowItem_1 = __importDefault(require("./IsValidObjectIdFlowItem"));
+var BuildConditionFlowItem_1 = __importDefault(require("./BuildConditionFlowItem"));
+var BuildRegexFlowItem_1 = __importDefault(require("./BuildRegexFlowItem"));
+var NormalizeValueFlowItem_1 = __importDefault(require("./NormalizeValueFlowItem"));
+var MatchFlowItem = /** @class */ (function () {
+    function MatchFlowItem() {
+    }
+    MatchFlowItem.prototype.exec = function (filters, model) {
+        // Recuperar todos os campos do tipo String
+        var camposString = !filters.searchTextFields ? ExtractFieldsOfTypeFlowItem_1.default.exec(model.schema, 'String') : filters.searchTextFields;
+        var andQueriesParam = {};
+        Object.entries(filters).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            if (value !== undefined || value === null) {
+                if ([
+                    'mainFilters',
+                    'or',
+                    'filters',
+                    'withTotalizers',
+                    'onlyMetadata',
+                    'projection',
+                    'pageable',
+                    'orderSense',
+                    'orderBy',
+                    'groupBy',
+                    'groupDetailed',
+                    'sumFields',
+                    'countFields',
+                    'properties',
+                    'populate',
+                    'page',
+                    'limit',
+                    'model',
+                    'select',
+                    'searchText',
+                    'searchTextFields',
+                    'sort',
+                    'isPageable',
+                    'searchPageable'
+                ].includes(key)) {
+                    return;
+                }
+                if (typeof value === 'string' && IsValidObjectIdFlowItem_1.default.exec(value) && key !== 'owner' && key !== 'identifier') {
+                    value = new mongoose_1.Types.ObjectId(value);
+                }
+                if (value === 'true') {
+                    value = true;
+                }
+                if (value === 'false') {
+                    value = false;
+                }
+                var condition = BuildConditionFlowItem_1.default.exec(key, value, model);
+                andQueriesParam = __assign(__assign({}, andQueriesParam), condition);
+            }
+        });
+        if (filters.searchText && camposString) {
+            var regex = BuildRegexFlowItem_1.default.exec(filters.searchText);
+            var conditions = { $or: [] };
+            for (var _i = 0, camposString_1 = camposString; _i < camposString_1.length; _i++) {
+                var fieldString = camposString_1[_i];
+                var conditionAux = {};
+                conditionAux[fieldString] = { $regex: regex };
+                conditions.$or.push(conditionAux);
+            }
+            andQueriesParam = __assign(__assign({}, andQueriesParam), conditions);
+        }
+        var orPayload = [];
+        if (filters === null || filters === void 0 ? void 0 : filters.or) {
+            var _loop_1 = function (clauseOr) {
+                var and = void 0;
+                var conditionsAnd;
+                Object.entries(clauseOr).forEach(function (_a) {
+                    var key = _a[0], value = _a[1];
+                    if (!value)
+                        return;
+                    value = NormalizeValueFlowItem_1.default.exec(key, value);
+                    var condition = BuildConditionFlowItem_1.default.exec(key, value, model);
+                    if (!conditionsAnd) {
+                        conditionsAnd = {};
+                    }
+                    conditionsAnd = __assign(__assign({}, conditionsAnd), condition);
+                });
+                if (conditionsAnd) {
+                    and = { $and: [conditionsAnd] };
+                }
+                if (and) {
+                    orPayload.push(and);
+                }
+            };
+            for (var _a = 0, _b = filters === null || filters === void 0 ? void 0 : filters.or; _a < _b.length; _a++) {
+                var clauseOr = _b[_a];
+                _loop_1(clauseOr);
+            }
+        }
+        var filtersFinal = __assign({}, andQueriesParam);
+        if (orPayload.length > 0) {
+            if (!filtersFinal.$or)
+                filtersFinal.$or = [];
+            filtersFinal.$or = __spreadArray(__spreadArray([], filtersFinal.$or, true), orPayload, true);
+        }
+        return filtersFinal;
+    };
+    return MatchFlowItem;
+}());
+exports.default = new MatchFlowItem;

package/dist/flow/searcher/item/NormalizeValueFlowItem.d.ts

@@ -0,0 +1,5 @@
+declare class NormalizeValueFlowItem {
+    exec(key: string, value: any): any;
+}
+declare const _default: NormalizeValueFlowItem;
+export default _default;