c2-mongoose 2.1.214 → 2.1.216

package/dist/flow/SearcherFlow.d.ts

@@ -0,0 +1,27 @@
+import mongoose from "mongoose";
+import { SearchOptions, SearchResponse } from "../types/SearchResponse";
+import SearchFlow from "./SearchFlow";
+export interface IPopulate {
+    [key: string]: any;
+    path: string;
+    select: string;
+    populate: IPopulate;
+}
+declare class SearcherFlow<D> {
+    private model;
+    [key: string]: any;
+    private searchText;
+    private orderSense;
+    private orderBy;
+    private page;
+    private limit;
+    private pageable;
+    private selection;
+    private populate;
+    constructor(repository: mongoose.Model<any>, search?: SearchFlow);
+    prepareSearch(search: any): void;
+    search(model: mongoose.Model<any>, options: SearchOptions): Promise<SearchResponse<D>>;
+    transformObject(originalObject: any): any;
+    buildDefaultFilters(objectSearch: any): any;
+}
+export default SearcherFlow;

package/dist/flow/SearcherFlow.js

@@ -0,0 +1,278 @@
+"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 __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 __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 Utils_1 = require("../utils/Utils");
+var BuildSelectSingleFlowItem_1 = __importDefault(require("./item/BuildSelectSingleFlowItem"));
+var BuildPopulateSingleFlowItem_1 = __importDefault(require("./item/BuildPopulateSingleFlowItem"));
+var moment_1 = __importDefault(require("moment"));
+var SearcherFlow = /** @class */ (function () {
+    function SearcherFlow(repository, search) {
+        this.searchText = "";
+        this.orderSense = "desc";
+        this.orderBy = "_id";
+        this.page = 1;
+        this.limit = 50;
+        this.pageable = true;
+        this.selection = [""];
+        this.populate = [""];
+        this.model = repository;
+        for (var key in search) {
+            this[key] = search[key];
+        }
+    }
+    SearcherFlow.prototype.prepareSearch = function (search) {
+        for (var key in search) {
+            this[key] = search[key];
+        }
+        // this.projection = this.buildProjections()
+        // this.populate = this.buildPopulate()
+        // this.buildOrdenation()
+    };
+    SearcherFlow.prototype.search = function (model, options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var stagesItems, stagesPaging, stagesMetadata, facet, _i, stagesMetadata_1, metadata, result, _a, resultAux;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        stagesItems = [];
+                        if ((0, Utils_1.isNotEmpty)(options.pipelines)) {
+                            stagesItems.push.apply(stagesItems, options.pipelines);
+                        }
+                        if ((0, Utils_1.isNotEmpty)(options.unions)) {
+                            stagesItems.push.apply(stagesItems, options.unions);
+                        }
+                        stagesItems.push({ $match: this.filters });
+                        if ((0, Utils_1.isNotEmpty)(this.projection)) {
+                            stagesItems.push({ $project: BuildSelectSingleFlowItem_1.default.build(model, this.select) });
+                        }
+                        // stagesItems.push({ $sort: this.sort })
+                        if (this.pageable === true) {
+                            stagesItems.push({ $skip: ((this.page - 1) * this.limit) || 0 });
+                            stagesItems.push({ $limit: this.limit });
+                        }
+                        stagesPaging = [];
+                        if ((0, Utils_1.isNotEmpty)(options.pipelines)) {
+                            stagesPaging.push.apply(stagesPaging, options.pipelines);
+                        }
+                        if ((0, Utils_1.isNotEmpty)(options.unions)) {
+                            stagesPaging.push.apply(stagesPaging, options.unions);
+                        }
+                        stagesPaging.push({ $match: this.filters });
+                        stagesPaging.push({ $count: "total" });
+                        stagesPaging.push({
+                            $addFields: {
+                                page: this.pageable === true ? this.page : 1,
+                                limit: this.pageable === true ? this.limit : '$total',
+                                totalPages: this.pageable === true ? {
+                                    $cond: {
+                                        if: { $eq: ['$total', 0] },
+                                        then: 0,
+                                        else: { $ceil: { $divide: ['$total', this.limit] } }
+                                    }
+                                } : 1,
+                                startIndex: this.pageable === true ? { $subtract: [{ $multiply: [this.page, this.limit] }, this.limit - 1] } : 1,
+                                endIndex: this.pageable === true ? { $multiply: [this.page, this.limit] } : '$total'
+                            }
+                        });
+                        stagesMetadata = [];
+                        if ((0, Utils_1.isNotEmpty)(options.metadata)) {
+                            stagesMetadata.push.apply(stagesMetadata, options.metadata);
+                        }
+                        facet = {};
+                        if (this.onlyMetadata === false || this.onlyMetadata === undefined) {
+                            facet.items = stagesItems;
+                            facet.paging = stagesPaging;
+                        }
+                        for (_i = 0, stagesMetadata_1 = stagesMetadata; _i < stagesMetadata_1.length; _i++) {
+                            metadata = stagesMetadata_1[_i];
+                            facet[metadata.id] = metadata.conditions;
+                        }
+                        return [4 /*yield*/, model.aggregate([
+                                {
+                                    $facet: facet
+                                },
+                            ], {
+                                collation: {
+                                    locale: "pt",
+                                    numericOrdering: true
+                                }
+                            }).session(options === null || options === void 0 ? void 0 : options.session)];
+                    case 1:
+                        result = _b.sent();
+                        if (!(0, Utils_1.isNotEmpty)(this.populate)) return [3 /*break*/, 3];
+                        _a = result[0];
+                        return [4 /*yield*/, model.populate(result[0].items, BuildPopulateSingleFlowItem_1.default.buildPopulate(model, this.populate, this.selection))];
+                    case 2:
+                        _a.items = _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        resultAux = this.transformObject(result[0]);
+                        return [2 /*return*/, resultAux];
+                }
+            });
+        });
+    };
+    SearcherFlow.prototype.transformObject = function (originalObject) {
+        var metadata = {};
+        var transformedObject = {};
+        for (var key in originalObject) {
+            if (key.startsWith('metadata-')) {
+                if (originalObject[key].length === 1) {
+                    metadata[key.replace("metadata-", "")] = originalObject[key][0];
+                    continue;
+                }
+                metadata[key.replace("metadata-", "")] = originalObject[key];
+            }
+            else {
+                transformedObject[key] = originalObject[key];
+            }
+        }
+        var hasPagination = (originalObject === null || originalObject === void 0 ? void 0 : originalObject.paging) ? true : false;
+        return __assign(__assign({}, transformedObject), { metadata: metadata, paging: hasPagination ? (originalObject === null || originalObject === void 0 ? void 0 : originalObject.paging[0]) || { total: 0, page: 1, limit: this.limit } : undefined });
+    };
+    SearcherFlow.prototype.buildDefaultFilters = function (objectSearch) {
+        var _this = this;
+        var filters = { $and: [] };
+        Object.entries(objectSearch).forEach(function (_a) {
+            var key = _a[0], value = _a[1];
+            if ((0, Utils_1.isNotEmpty)(value)) {
+                var condition = {};
+                if ([
+                    'onlyMetadata',
+                    'projection',
+                    'pageable',
+                    'orderSense',
+                    'orderBy',
+                    'properties',
+                    'populate',
+                    'page',
+                    'limit',
+                    'model',
+                    'select',
+                    'searchText',
+                    'sort',
+                    'isPageable',
+                    'searchPageable'
+                ].includes(key)) {
+                    return;
+                }
+                if (typeof value === 'string' && _this.isValidObjectId(value)) {
+                    value = new mongoose_1.Types.ObjectId(value);
+                }
+                if (value === 'true') {
+                    value = true;
+                }
+                if (value === 'false') {
+                    value = false;
+                }
+                if (key.endsWith('DateRange') || key.endsWith('DateTimeRange')) {
+                    var fieldName = key.replace('Range', '');
+                    var values = value;
+                    if ((0, Utils_1.isNotEmpty)(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', true).toDate() });
+                    }
+                    if ((0, Utils_1.isNotEmpty)(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', true).toDate() });
+                    }
+                    filters.$and.push(condition);
+                }
+                else if (key.endsWith('Like')) {
+                    var fieldName = key.replace('Like', '');
+                    condition[fieldName] = _this.buildRegex(value); //{ $regex: value as any, $options: 'i' }
+                    filters.$and.push(condition);
+                }
+                else if (key.endsWith('Exists')) {
+                    var fieldName = key.replace('Exists', '');
+                    condition[fieldName] = { $exists: value };
+                    filters.$and.push(condition);
+                }
+                else {
+                    if (!Array.isArray(value)) {
+                        condition[key] = value;
+                    }
+                    else {
+                        var arr = [];
+                        for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
+                            var val = value_1[_i];
+                            if (typeof val === 'string' && _this.isValidObjectId(val)) {
+                                val = new mongoose_1.Types.ObjectId(val);
+                            }
+                            arr.push(val);
+                        }
+                        if (key.startsWith("notIn")) {
+                            key = key.replace("notIn", "");
+                            condition[key] = { $nin: arr };
+                        }
+                        else {
+                            condition[key] = { $in: arr };
+                        }
+                    }
+                    filters.$and.push(condition);
+                }
+            }
+        });
+        if (filters.$and.length === 0)
+            delete filters['$and'];
+        return filters;
+    };
+    return SearcherFlow;
+}());
+exports.default = SearcherFlow;

package/dist/flow/item/BuildPopulateSingleFlowItem.d.ts

@@ -0,0 +1,8 @@
+import mongoose from "mongoose";
+import { IPopulate } from "../SearcherFlow";
+declare class BuildPopulateSingleFlowItem {
+    buildPopulate(model: mongoose.Model<any>, populatesStr: string[], selectsStr: string[]): IPopulate[];
+    buildPath(target: string, nested?: string): IPopulate;
+}
+declare const _default: BuildPopulateSingleFlowItem;
+export default _default;

package/dist/flow/item/BuildPopulateSingleFlowItem.js

@@ -0,0 +1,63 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var Utils_1 = require("../../utils/Utils");
+var BuildPopulateSingleFlowItem = /** @class */ (function () {
+    function BuildPopulateSingleFlowItem() {
+    }
+    BuildPopulateSingleFlowItem.prototype.buildPopulate = function (model, populatesStr, selectsStr) {
+        var _a, _b, _c, _d;
+        var populate = [];
+        if ((0, Utils_1.isEmpty)(populatesStr)) {
+            return [];
+        }
+        var _loop_1 = function () {
+            var _e = property.split('.'), first = _e[0], rest = _e.slice(1);
+            var nested = rest.join('.');
+            var populateLocal = this_1.buildPath(first, nested);
+            if (Array.isArray(selectsStr)) {
+                var selects = selectsStr.filter(function (sel) { return sel.startsWith("".concat(first, ".")); });
+                var select = selects.map(function (sel) { return sel.split(".")[1]; }).join(" ");
+                if ((0, Utils_1.isNotEmpty)(select)) {
+                    populateLocal.select = select;
+                }
+            }
+            var existing = populate.find(function (populateAux) { return populateAux.path === populateLocal.path; });
+            if (existing) {
+                var populateAux = __assign(__assign({}, existing === null || existing === void 0 ? void 0 : existing.populate), { path: "".concat((_b = (_a = existing.populate) === null || _a === void 0 ? void 0 : _a.path) !== null && _b !== void 0 ? _b : "", " ").concat((_d = (_c = populateLocal.populate) === null || _c === void 0 ? void 0 : _c.path) !== null && _d !== void 0 ? _d : "").trim() });
+                existing.populate = populateAux;
+                return "continue";
+            }
+            populate.push(populateLocal);
+        };
+        var this_1 = this;
+        for (var _i = 0, populatesStr_1 = populatesStr; _i < populatesStr_1.length; _i++) {
+            var property = populatesStr_1[_i];
+            _loop_1();
+        }
+        return populate;
+    };
+    BuildPopulateSingleFlowItem.prototype.buildPath = function (target, nested) {
+        if (nested === void 0) { nested = ""; }
+        var populate = {};
+        populate.path = target;
+        if ((0, Utils_1.isNotEmpty)(nested)) {
+            var _a = nested.split('.'), first = _a[0], rest = _a.slice(1);
+            var nested2 = rest.join('.');
+            populate.populate = this.buildPath(first, nested2);
+        }
+        return populate;
+    };
+    return BuildPopulateSingleFlowItem;
+}());
+exports.default = new BuildPopulateSingleFlowItem;

package/dist/flow/item/BuildSelectPopulateFlowItem.js

@@ -10,7 +10,7 @@ var BuildSelectPopulateFlowItem = /** @class */ (function () {
         if (campoInfo.instance === "ObjectID") {
             return undefined;
         }
-        if ((0, Utils_1.isEmpty)(projection[path]) || isNaN(projection[path]) === false) {
+        if ((0, Utils_1.isEmpty)(projection) || (0, Utils_1.isEmpty)(projection[path]) || isNaN(projection[path]) === false) {
             return undefined;
         }
         return projection[path];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.214",
+  "version": "2.1.216",
   "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/SearchFlow.ts

@@ -520,25 +520,6 @@ abstract class SearchFlow {
 
     return filters
   }
-
-  // public addFilterModel(model: any, filters: any) {
-  //   Object.entries(model).forEach(([key, value]) => {
-  //     if (key.endsWith('DateRange')) {
-  //       return
-  //     }
-  //     if (key.endsWith('Like')) {
-  //       return
-  //     }
-  //     if (['onlyMetadata', 'projection', 'pageable', 'orderSense', 'orderBy', 'properties', 'populate', 'page', 'limit', 'model', 'select', 'searchText', 'isPageable', 'searchPageable'].includes(key)) {
-  //       return
-  //     }
-  //     if (isNotEmpty(value)) {
-  //       let condition = {} as any
-  //       condition[key] = value
-  //       filters.$and.push(condition)
-  //     }
-  //   })
-  // }
 }
 
 export default SearchFlow

package/src/flow/SearcherFlow.ts

@@ -0,0 +1,261 @@
+import mongoose, { ClientSession, Types } from "mongoose"
+import { SearchOptions, SearchResponse } from "../types/SearchResponse"
+import { isEmpty, isNotEmpty } from "../utils/Utils"
+import SearchFlow from "./SearchFlow"
+import BuildSelectSingleFlowItem from "./item/BuildSelectSingleFlowItem"
+import BuildPopulateSingleFlowItem from "./item/BuildPopulateSingleFlowItem"
+import moment from "moment"
+export interface IPopulate {
+    [key: string]: any
+    path: string
+    select: string
+    populate: IPopulate
+}
+
+class SearcherFlow<D> {
+
+    private model: mongoose.Model<any>
+
+    [key: string]: any
+    private searchText: string = ""
+    private orderSense: string = "desc"
+    private orderBy: string = "_id"
+    private page: number = 1
+    private limit: number = 50
+    private pageable: boolean = true
+
+    private selection: string[] = [""]
+    private populate: string[] = [""]
+
+    constructor(repository: mongoose.Model<any>, search?: SearchFlow) {
+        this.model = repository
+        for (const key in search) {
+            this[key] = search[key];
+        }
+    }
+
+    public prepareSearch(search: any) {
+        for (const key in search) {
+            this[key] = search[key];
+        }
+
+        // this.projection = this.buildProjections()
+        // this.populate = this.buildPopulate()
+        // this.buildOrdenation()
+    }
+
+    async search(model: mongoose.Model<any>, options: SearchOptions): Promise<SearchResponse<D>> {
+
+        let stagesItems: any[] = []
+
+        if (isNotEmpty(options.pipelines)) {
+            stagesItems.push(...options.pipelines)
+        }
+        if (isNotEmpty(options.unions)) {
+            stagesItems.push(...options.unions)
+        }
+
+        stagesItems.push({ $match: this.filters })
+
+        if (isNotEmpty(this.projection)) {
+            stagesItems.push({ $project: BuildSelectSingleFlowItem.build(model, this.select) })
+        }
+
+        // stagesItems.push({ $sort: this.sort })
+        if (this.pageable === true) {
+            stagesItems.push({ $skip: ((this.page - 1) * this.limit) || 0 })
+            stagesItems.push({ $limit: this.limit })
+        }
+
+
+        let stagesPaging: any[] = []
+        if (isNotEmpty(options.pipelines)) {
+            stagesPaging.push(...options.pipelines)
+        }
+        if (isNotEmpty(options.unions)) {
+            stagesPaging.push(...options.unions)
+        }
+
+        stagesPaging.push({ $match: this.filters })
+        stagesPaging.push({ $count: "total" })
+        stagesPaging.push({
+            $addFields: {
+                page: this.pageable === true ? this.page : 1,
+                limit: this.pageable === true ? this.limit : '$total',
+                totalPages: this.pageable === true ? {
+                    $cond: {
+                        if: { $eq: ['$total', 0] },
+                        then: 0,
+                        else: { $ceil: { $divide: ['$total', this.limit] } }
+                    }
+                } : 1,
+                startIndex: this.pageable === true ? { $subtract: [{ $multiply: [this.page, this.limit] }, this.limit - 1] } : 1,
+                endIndex: this.pageable === true ? { $multiply: [this.page, this.limit] } : '$total'
+            }
+        })
+
+        let stagesMetadata: any[] = []
+        if (isNotEmpty(options.metadata)) {
+            stagesMetadata.push(...options.metadata)
+        }
+
+        const facet: { [key: string]: any } = {}
+        if (this.onlyMetadata === false || this.onlyMetadata === undefined) {
+            facet.items = stagesItems
+            facet.paging = stagesPaging
+        }
+
+        for (let metadata of stagesMetadata) {
+            facet[metadata.id] = metadata.conditions
+        }
+
+        const result = await model.aggregate(
+            [
+                {
+                    $facet: facet
+                },
+            ], {
+            collation: {
+                locale: "pt",
+                numericOrdering: true
+            }
+        }).session(options?.session as ClientSession)
+
+
+        if (isNotEmpty(this.populate)) {
+            result[0].items = await model.populate(result[0].items, BuildPopulateSingleFlowItem.buildPopulate(model, this.populate, this.selection))
+        }
+
+        let resultAux = this.transformObject(result[0])
+        return resultAux
+    }
+
+    transformObject(originalObject: any): any {
+        const metadata: any = {};
+        const transformedObject: any = {};
+
+        for (const key in originalObject) {
+            if (key.startsWith('metadata-')) {
+                if (originalObject[key].length === 1) {
+                    metadata[key.replace("metadata-", "")] = originalObject[key][0]
+                    continue
+                }
+                metadata[key.replace("metadata-", "")] = originalObject[key]
+            } else {
+                transformedObject[key] = originalObject[key];
+            }
+        }
+
+        let hasPagination = originalObject?.paging ? true : false
+
+        return {
+            ...transformedObject,
+            metadata,
+            paging: hasPagination ? originalObject?.paging[0] || { total: 0, page: 1, limit: this.limit } : undefined,
+        };
+    }
+
+    public buildDefaultFilters(objectSearch: any) {
+        let filters = { $and: [] } as any
+        Object.entries(objectSearch).forEach(([key, value]) => {
+            if (isNotEmpty(value)) {
+                let condition = {} as any
+                if ([
+                    'onlyMetadata',
+                    'projection',
+                    'pageable',
+                    'orderSense',
+                    'orderBy',
+                    'properties',
+                    'populate',
+                    'page',
+                    'limit',
+                    'model',
+                    'select',
+                    'searchText',
+                    'sort',
+                    'isPageable',
+                    'searchPageable'].includes(key)) {
+                    return
+                }
+
+                if (typeof value === 'string' && this.isValidObjectId(value as string)) {
+                    value = new Types.ObjectId(value as string)
+                }
+
+                if (value === 'true') {
+                    value = true
+                }
+
+                if (value === 'false') {
+                    value = false
+                }
+
+                if (key.endsWith('DateRange') || key.endsWith('DateTimeRange')) {
+                    var fieldName = key.replace('Range', '')
+                    var values = value as any
+                    if (isNotEmpty(values[0])) {
+                        var momentValue = moment(values[0])
+                        momentValue.hour(0)
+                        momentValue.minute(0)
+                        momentValue.second(0)
+                        condition[fieldName] = {
+                            ...condition[fieldName],
+                            $gte: momentValue.tz('America/Sao_Paulo', true).toDate()
+                        }
+                    }
+
+                    if (isNotEmpty(values[1])) {
+                        var momentValue = moment(values[1])
+                        momentValue.hour(23)
+                        momentValue.minute(59)
+                        momentValue.second(59)
+                        condition[fieldName] = {
+                            ...condition[fieldName],
+                            $lte: momentValue.tz('America/Sao_Paulo', true).toDate()
+                        }
+                    }
+                    filters.$and.push(condition)
+                } else if (key.endsWith('Like')) {
+                    var fieldName = key.replace('Like', '')
+                    condition[fieldName] = this.buildRegex(value as string) //{ $regex: value as any, $options: 'i' }
+                    filters.$and.push(condition)
+                } else if (key.endsWith('Exists')) {
+                    var fieldName = key.replace('Exists', '')
+                    condition[fieldName] = { $exists: value as boolean }
+                    filters.$and.push(condition)
+                }
+
+                else {
+                    if (!Array.isArray(value)) {
+                        condition[key] = value
+                    } else {
+                        let arr = []
+                        for (let val of value) {
+                            if (typeof val === 'string' && this.isValidObjectId(val as string)) {
+                                val = new Types.ObjectId(val as string)
+                            }
+                            arr.push(val)
+                        }
+
+                        if (key.startsWith("notIn")) {
+                            key = key.replace("notIn", "")
+                            condition[key] = { $nin: arr }
+                        } else {
+                            condition[key] = { $in: arr }
+                        }
+
+                    }
+                    filters.$and.push(condition)
+                }
+            }
+        })
+
+        if (filters.$and.length === 0)
+            delete filters['$and']
+
+        return filters
+    }
+}
+
+export default SearcherFlow

package/src/flow/item/BuildPopulateSingleFlowItem.ts

@@ -0,0 +1,55 @@
+import mongoose from "mongoose";
+import { isEmpty, isNotEmpty } from "../../utils/Utils";
+import { IPopulate } from "../SearcherFlow";
+
+class BuildPopulateSingleFlowItem {
+
+  public buildPopulate(model: mongoose.Model<any>, populatesStr: string[], selectsStr: string[]): IPopulate[] {
+    var populate = [] as IPopulate[]
+    if (isEmpty(populatesStr)) {
+      return []
+    }
+
+    for (var property of populatesStr) {
+      let [first, ...rest] = property.split('.')
+      let nested = rest.join('.')
+
+      let populateLocal = this.buildPath(first, nested)
+
+      if (Array.isArray(selectsStr)) {
+        let selects = (selectsStr as []).filter((sel: string) => sel.startsWith(`${first}.`))
+        let select = selects.map((sel: string) => sel.split(".")[1]).join(" ")
+        if (isNotEmpty(select)) {
+          populateLocal.select = select
+        }
+      }
+
+      const existing = populate.find((populateAux: IPopulate) => populateAux.path === populateLocal.path)
+      if (existing) {
+        const populateAux = {
+          ...existing?.populate,
+          path: `${existing.populate?.path ?? ``} ${populateLocal.populate?.path ?? ``}`.trim()
+        }
+        existing.populate = populateAux
+        continue
+      }
+
+      populate.push(populateLocal)
+    }
+
+    return populate
+  }
+
+  public buildPath(target: string, nested: string = ""): IPopulate {
+    var populate = {} as IPopulate
+    populate.path = target
+    if (isNotEmpty(nested)) {
+      let [first, ...rest] = nested.split('.')
+      let nested2 = rest.join('.')
+      populate.populate = this.buildPath(first, nested2)
+    }
+    return populate
+  }
+}
+
+export default new BuildPopulateSingleFlowItem

package/src/flow/item/BuildSelectPopulateFlowItem.ts

@@ -12,7 +12,7 @@ class BuildSelectPopulateFlowItem {
       return undefined
     }
 
-    if (isEmpty(projection[path]) || isNaN(projection[path]) === false) {
+    if (isEmpty(projection) || isEmpty(projection[path]) || isNaN(projection[path]) === false) {
       return undefined
     }
     return projection[path];