c2-mongoose 2.1.319 → 2.1.321

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

@@ -0,0 +1,25 @@
+"use strict";
+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 IsValidObjectIdFlowItem_1 = __importDefault(require("./IsValidObjectIdFlowItem"));
+var NormalizeValueFlowItem = /** @class */ (function () {
+    function NormalizeValueFlowItem() {
+    }
+    NormalizeValueFlowItem.prototype.exec = function (key, value) {
+        if (typeof value === 'string' && IsValidObjectIdFlowItem_1.default.exec(value) && key !== 'owner') {
+            value = new mongoose_1.Types.ObjectId(value);
+        }
+        if (value === 'true') {
+            value = true;
+        }
+        if (value === 'false') {
+            value = false;
+        }
+        return value;
+    };
+    return NormalizeValueFlowItem;
+}());
+exports.default = new NormalizeValueFlowItem;

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

@@ -0,0 +1,6 @@
+import mongoose from "mongoose";
+declare class PopulateFlowItem {
+    exec(populate: never[] | undefined, modelRoot: mongoose.Model<any>): any[];
+}
+declare const _default: PopulateFlowItem;
+export default _default;

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

@@ -0,0 +1,101 @@
+"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 mongoose_1 = __importDefault(require("mongoose"));
+var PopulateFlowItem = /** @class */ (function () {
+    function PopulateFlowItem() {
+    }
+    PopulateFlowItem.prototype.exec = function (populate, modelRoot) {
+        if (populate === void 0) { populate = []; }
+        var populateClauses = [];
+        populate.forEach(function (populateField) {
+            var _a, _b;
+            var _c = populateField.split('.'), first = _c[0], rest = _c.slice(1);
+            var fieldDefinition = modelRoot.schema.path(first);
+            var typeFirst = fieldDefinition.instance;
+            if (typeFirst === 'Array') {
+                if (rest === null || rest === void 0 ? void 0 : rest.length) {
+                    first = [first, rest[0]].join(".");
+                    rest.splice(0, 1);
+                    fieldDefinition = modelRoot.schema.path(first);
+                }
+            }
+            if (!fieldDefinition || !fieldDefinition.options || !fieldDefinition.options.ref) {
+                throw new Error("[1]No reference found for populate field: ".concat(populateField));
+            }
+            var modelName = fieldDefinition.options.ref;
+            var refModel = mongoose_1.default.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) === first; })) {
+                var populateClauseLookup = [
+                    {
+                        $lookup: {
+                            from: collectionName,
+                            localField: first,
+                            foreignField: "_id",
+                            as: first
+                        }
+                    },
+                ];
+                if (typeFirst !== 'Array') {
+                    populateClauseLookup.push({
+                        $addFields: (_a = {},
+                            _a["".concat(first)] = { $ifNull: [{ $arrayElemAt: ["$".concat(first), 0] }, undefined] },
+                            _a)
+                    });
+                }
+                populateClauses = __spreadArray(__spreadArray([], populateClauses, true), populateClauseLookup, true);
+            }
+            if ((rest === null || rest === void 0 ? void 0 : rest.length) > 0) {
+                var pathRelativeCurrent_1 = first;
+                for (var _i = 0, rest_1 = rest; _i < rest_1.length; _i++) {
+                    var nextField = rest_1[_i];
+                    pathRelativeCurrent_1 += ".".concat(nextField);
+                    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.startsWith(pathRelativeCurrent_1); })) {
+                        break;
+                    }
+                    fieldDefinition = refModel.schema.path(nextField);
+                    if (!fieldDefinition || !fieldDefinition.options || !fieldDefinition.options.ref) {
+                        throw new Error("[1]No reference found for populate field: ".concat(populateField));
+                    }
+                    modelName = fieldDefinition.options.ref;
+                    refModel = mongoose_1.default.model(modelName);
+                    collectionName = refModel.collection.name;
+                    var populateClauseLookup = [
+                        {
+                            $lookup: {
+                                from: collectionName,
+                                localField: pathRelativeCurrent_1,
+                                foreignField: "_id",
+                                as: pathRelativeCurrent_1
+                            }
+                        }
+                    ];
+                    if (typeFirst !== 'Array') {
+                        populateClauseLookup.push({
+                            $addFields: (_b = {},
+                                _b["".concat(pathRelativeCurrent_1)] = { $ifNull: [{ $arrayElemAt: ["$".concat(pathRelativeCurrent_1), 0] }, undefined] },
+                                _b)
+                        });
+                    }
+                    populateClauses = __spreadArray(__spreadArray([], populateClauses, true), populateClauseLookup, true);
+                }
+                return;
+            }
+        });
+        return populateClauses;
+    };
+    return PopulateFlowItem;
+}());
+exports.default = new PopulateFlowItem;

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

@@ -0,0 +1,5 @@
+declare class ProjectFlowItem {
+    exec(select?: any[]): any;
+}
+declare const _default: ProjectFlowItem;
+export default _default;

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

@@ -0,0 +1,42 @@
+"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 ProjectFlowItem = /** @class */ (function () {
+    function ProjectFlowItem() {
+    }
+    ProjectFlowItem.prototype.exec = function (select) {
+        if (select === void 0) { select = []; }
+        var nested = function (projectCurrent, field, include) {
+            var _a = field.split('.'), first = _a[0], rest = _a.slice(1);
+            if (rest.length === 0) {
+                projectCurrent[first] = include ? 1 : 0;
+                return projectCurrent;
+            }
+            projectCurrent[first] = __assign(__assign({}, projectCurrent[first]), nested(projectCurrent[first] || {}, rest.join("."), include));
+            return projectCurrent;
+        };
+        if (!(select === null || select === void 0 ? void 0 : select.length))
+            return [];
+        var selectClauses = {
+            $project: {}
+        };
+        select.forEach(function (selectField) {
+            var include = selectField.startsWith("-") ? false : true;
+            selectField = selectField.replace("-", "");
+            selectClauses.$project = nested(selectClauses.$project, selectField, include);
+        });
+        return [selectClauses];
+    };
+    return ProjectFlowItem;
+}());
+exports.default = new ProjectFlowItem;

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

@@ -0,0 +1,5 @@
+declare class SortFlowItem {
+    exec(orderBy: string, orderSense: string): any[];
+}
+declare const _default: SortFlowItem;
+export default _default;

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var SortFlowItem = /** @class */ (function () {
+    function SortFlowItem() {
+    }
+    SortFlowItem.prototype.exec = function (orderBy, orderSense) {
+        var sort = {};
+        sort[orderBy] = orderSense === "desc" ? -1 : 1;
+        return [{ $sort: sort }];
+    };
+    return SortFlowItem;
+}());
+exports.default = new SortFlowItem;

package/dist/index.d.ts

@@ -9,9 +9,10 @@ import BuildPipelineToJoinFlowItem from "./flow/item/BuildPipelineToJoinFlowItem
 import BuildPopulateSingleFlowItem from "./flow/item/BuildPopulateSingleFlowItem";
 import BuildSelectSingleFlowItem from "./flow/item/BuildSelectSingleFlowItem";
 import ConvertToSearchResponseFlowItem from "./flow/item/ConvertToSearchResponseFlowItem";
+import SearcherV2Flow from "./flow/searcher/SearcherV2Flow";
 import { IFacet } from "./model/Facet";
 import { ILogger, LoggerModel, LoggerSearch, TypeOfOperation } from "./model/Logger";
 import { Options } from "./types/Options";
 import { Pagination, SearchResponse } from "./types/SearchResponse";
 import { initialize } from "./utils/Utils";
-export { AddStagePaginationFlowItem, AddStageSortFlowItem, BuildPipelineToCountJoinFlowItem, BuildPipelineToJoinFlowItem, BuildPopulateSingleFlowItem, BuildSelectSingleFlowItem, C2Flow, ConvertToSearchResponseFlowItem, CrudFlow, IFacet, ILogger, LoggerModel, LoggerSearch, Options, Pagination, SearchFlow, SearchResponse, SearcherFlow, TypeOfOperation, initialize };
+export { AddStagePaginationFlowItem, AddStageSortFlowItem, BuildPipelineToCountJoinFlowItem, BuildPipelineToJoinFlowItem, BuildPopulateSingleFlowItem, BuildSelectSingleFlowItem, C2Flow, ConvertToSearchResponseFlowItem, CrudFlow, IFacet, ILogger, LoggerModel, LoggerSearch, Options, Pagination, SearchFlow, SearchResponse, SearcherFlow, TypeOfOperation, initialize, SearcherV2Flow };

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize = exports.TypeOfOperation = exports.SearcherFlow = exports.SearchFlow = exports.LoggerSearch = exports.LoggerModel = exports.CrudFlow = exports.ConvertToSearchResponseFlowItem = exports.C2Flow = exports.BuildSelectSingleFlowItem = exports.BuildPopulateSingleFlowItem = exports.BuildPipelineToJoinFlowItem = exports.BuildPipelineToCountJoinFlowItem = exports.AddStageSortFlowItem = exports.AddStagePaginationFlowItem = void 0;
+exports.SearcherV2Flow = exports.initialize = exports.TypeOfOperation = exports.SearcherFlow = exports.SearchFlow = exports.LoggerSearch = exports.LoggerModel = exports.CrudFlow = exports.ConvertToSearchResponseFlowItem = exports.C2Flow = exports.BuildSelectSingleFlowItem = exports.BuildPopulateSingleFlowItem = exports.BuildPipelineToJoinFlowItem = exports.BuildPipelineToCountJoinFlowItem = exports.AddStageSortFlowItem = exports.AddStagePaginationFlowItem = void 0;
 var C2Flow_1 = __importDefault(require("./flow/C2Flow"));
 exports.C2Flow = C2Flow_1.default;
 var CrudFlow_1 = __importDefault(require("./flow/CrudFlow"));
@@ -26,6 +26,8 @@ var BuildSelectSingleFlowItem_1 = __importDefault(require("./flow/item/BuildSele
 exports.BuildSelectSingleFlowItem = BuildSelectSingleFlowItem_1.default;
 var ConvertToSearchResponseFlowItem_1 = __importDefault(require("./flow/item/ConvertToSearchResponseFlowItem"));
 exports.ConvertToSearchResponseFlowItem = ConvertToSearchResponseFlowItem_1.default;
+var SearcherV2Flow_1 = __importDefault(require("./flow/searcher/SearcherV2Flow"));
+exports.SearcherV2Flow = SearcherV2Flow_1.default;
 var Logger_1 = require("./model/Logger");
 Object.defineProperty(exports, "LoggerModel", { enumerable: true, get: function () { return Logger_1.LoggerModel; } });
 Object.defineProperty(exports, "LoggerSearch", { enumerable: true, get: function () { return Logger_1.LoggerSearch; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c2-mongoose",
-  "version": "2.1.319",
+  "version": "2.1.321",
   "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/SearcherFlow.ts

@@ -219,14 +219,14 @@ class SearcherFlow<D> {
             if (isNotEmpty(values[0])) {
                 condition[fieldName] = {
                     ...condition[fieldName],
-                    $gte: values[0]
+                    $gte: Number(values[0])
                 }
             }
 
             if (isNotEmpty(values[1])) {
                 condition[fieldName] = {
                     ...condition[fieldName],
-                    $lte: values[1]
+                    $lte: Number(values[1])
                 }
             }
         } else if (key.endsWith('Like')) {

package/src/flow/searcher/SearcherV2Flow.ts

@@ -0,0 +1,65 @@
+import mongoose from "mongoose"
+import GroupFlowItem from "./item/GroupFlowItem"
+import PopulateFlowItem from "./item/PopulateFlowItem"
+import SortFlowItem from "./item/SortFlowItem"
+import ProjectFlowItem from "./item/ProjectFlowItem"
+import MatchFlowItem from "./item/MatchFlowItem"
+import BuildPaginationDataFlowItem from "./item/BuildPaginationDataFlowItem"
+
+export interface IParams {
+  [key: string]: any
+  mainFilter: any
+}
+
+class SearcherV2Flow {
+
+  async exec(params: IParams, model: mongoose.Model<any>) {
+    const facet: any = {}
+    let pipelineFacetPaging: any[] = []
+    let pipelineFacetItems: any[] = [
+      ...GroupFlowItem.exec(params.groupBy, params.sumFields, params.groupDetailed, model),
+      ...PopulateFlowItem.exec(params.populate, model),
+      ...MatchFlowItem.exec(params, model),
+      ...SortFlowItem.exec(params.orderBy, params.orderSense),
+      ...ProjectFlowItem.exec(params.select),
+    ]
+
+
+    if (params.pageable) {
+      pipelineFacetItems = [
+        ...pipelineFacetItems,
+        { $skip: ((params.page - 1) * params.limit) },
+        { $limit: params.limit }
+      ]
+
+      pipelineFacetPaging = [
+        ...GroupFlowItem.exec(params.groupBy, params.sumFields, params.groupDetailed, model),
+        ...PopulateFlowItem.exec(params.populate, model),
+        ...MatchFlowItem.exec(params, model),
+        ...BuildPaginationDataFlowItem.exec(params.page, params.limit),
+      ]
+      facet.paging = pipelineFacetPaging
+    }
+    facet.items = pipelineFacetItems
+
+    let result = await model.aggregate([
+      {
+        $match: MatchFlowItem.exec(params.mainFilter, model)
+      },
+      {
+        $facet: facet
+      }
+    ])
+
+    const ret: any = {}
+    ret.items = result[0].items
+
+    if (params.pageable) {
+      ret.paging = result[0].paging[0]
+    }
+
+    return ret
+  }
+}
+
+export default new SearcherV2Flow

package/src/flow/searcher/item/BuildConditionFlowItem.ts

@@ -0,0 +1,126 @@
+import moment from "moment"
+import mongoose, { Types } from "mongoose"
+import BuildRegexFlowItem from "./BuildRegexFlowItem"
+import IsValidObjectIdFlowItem from "./IsValidObjectIdFlowItem"
+
+class BuildConditionFlowItem {
+  exec(key: string, value: any, model: mongoose.Model<any>) {
+    let condition = {} as any
+    if (key.endsWith('DateRange')) {
+      var fieldName = key.replace('Range', '')
+      var values = value as any
+      if (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', false).toDate()
+        }
+      }
+
+      if (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', false).toDate()
+        }
+      }
+    } else if (key.endsWith('DateTimeRange')) {
+      var fieldName = key.replace('Range', '')
+      var values = value as any
+      if (values[0]) {
+        var momentValue = moment(values[0])
+        condition[fieldName] = {
+          ...condition[fieldName],
+          $gte: momentValue.tz('America/Sao_Paulo', false).toDate()
+        }
+      }
+
+      if (values[1]) {
+        var momentValue = moment(values[1])
+        condition[fieldName] = {
+          ...condition[fieldName],
+          $lte: momentValue.tz('America/Sao_Paulo', false).toDate()
+        }
+      }
+    } else if (key.endsWith('Range')) {
+      var fieldName = key.replace('Range', '')
+      var values = value as any
+      if (values[0]) {
+        condition[fieldName] = {
+          ...condition[fieldName],
+          $gte: Number(values[0])
+        }
+      }
+
+      if (values[1]) {
+        condition[fieldName] = {
+          ...condition[fieldName],
+          $lte: Number(values[1])
+        }
+      }
+    } else if (key.endsWith('Like')) {
+      var fieldName = key.replace('Like', '')
+      condition[fieldName] = BuildRegexFlowItem.exec(value as string) //{ $regex: value as any, $options: 'i' }
+    } else if (key.endsWith("AtLeastOneExists")) {
+      key = key.replace("AtLeastOneExists", "");
+
+      const fields = key.split('.')
+      if (!fields) return condition;
+
+      condition[fields[0]] = { $elemMatch: { [fields[1]]: { $exists: value as boolean } } }
+    } else if (key.endsWith('Exists')) {
+      var fieldName = key.replace('Exists', '')
+      condition[fieldName] = { $exists: value as boolean }
+    } else if (key.endsWith("IsEmpty")) {
+      key = key.replace("IsEmpty", "");
+      condition[key] = value ? { $size: 0 } : { $not: { $size: 0 } };
+    } else {
+      if (model?.schema?.paths[key]?.instance === 'Array') {
+        if (!Array.isArray(value)) {
+          value = [value]
+        }
+
+        (value as [])?.forEach((v: any) => {
+          if (typeof v === 'string' && IsValidObjectIdFlowItem.exec(v)) {
+            v = new 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.exec(val)) {
+            val = new 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
+
+  }
+}
+
+export default new BuildConditionFlowItem

package/src/flow/searcher/item/BuildPaginationDataFlowItem.ts

@@ -0,0 +1,31 @@
+class BuildPaginationDataFlowItem {
+  exec(page: number, limit: number): any[] {
+    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] }
+            }
+          }
+        }
+      }
+    ]
+  }
+}
+
+export default new BuildPaginationDataFlowItem

package/src/flow/searcher/item/BuildRegexFlowItem.ts

@@ -0,0 +1,20 @@
+class BuildRegexFlowItem {
+  exec(searchText: string): RegExp {
+    const 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(`${regexExpression}`, 'i');
+}
+}
+
+export default new BuildRegexFlowItem

package/src/flow/searcher/item/ExtractFieldsOfTypeFlowItem.ts

@@ -0,0 +1,20 @@
+import { Schema } from "mongoose"
+
+class ExtractFieldsOfTypeFlowItem {
+
+  exec(schema: Schema, typing = 'String', parent = ''): string[] {
+    let fieldsTyped: string[] = []
+    Object.keys(schema.paths).forEach((field: string) => {
+        if (schema.paths[field].instance === typing) {
+            fieldsTyped.push(`${parent !== '' ? `${parent}.` : ''}${field}`)
+        } else if (schema.paths[field].instance === 'Embedded') {
+            fieldsTyped = [...fieldsTyped, ...this.exec(schema.paths[field].schema, typing, field)]
+        }
+    })
+
+    return fieldsTyped
+}
+
+}
+
+export default new ExtractFieldsOfTypeFlowItem

package/src/flow/searcher/item/GetTypeOfFieldInModelFlowItem.ts

@@ -0,0 +1,10 @@
+import mongoose from "mongoose"
+
+class GetTypeOfFieldInModelFlowItem {
+  exec(fieldToGroup: string, modelRoot: mongoose.Model<any, {}, {}, {}, any, any>): string {
+    let fieldDefinition = modelRoot.schema.path(fieldToGroup)
+    return fieldDefinition.instance
+  }
+}
+
+export default new GetTypeOfFieldInModelFlowItem

package/src/flow/searcher/item/GroupFlowItem.ts

@@ -0,0 +1,86 @@
+import mongoose from "mongoose";
+import GetTypeOfFieldInModelFlowItem from "./GetTypeOfFieldInModelFlowItem";
+
+class GroupFlowItem {
+  exec(fieldToGroup: string, sumFields: string, detailed: boolean, modelRoot: mongoose.Model<any>): any[] {
+    if (!fieldToGroup) return []
+
+    const sumField = sumFields ? sumFields[0] : undefined
+
+    const groupsClauses = []
+
+    let [first] = fieldToGroup.split('.')
+    const typeOfFieldToGroup = GetTypeOfFieldInModelFlowItem.exec(first, modelRoot)
+    if (typeOfFieldToGroup === "Array") {
+      groupsClauses.push({
+        $unwind: {
+          path: `$${first}`,
+          preserveNullAndEmptyArrays: true,
+        }
+      })
+    }
+
+    let groupField: any = `$${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: `$${fieldToGroup}`
+        }
+      }
+    }
+
+    const groupClause: any = {
+      $group: {
+        _id: groupField,
+        count: { $sum: 1 }
+      }
+    }
+
+    if (detailed) {
+      groupClause.$group.docs = { $push: "$$ROOT" }
+    }
+
+
+    if (sumField) {
+      const tempFieldName = sumField.replace(/\./g, '_')
+
+      let [firstSumField] = sumField.split('.')
+      const typeOfFieldToSum = GetTypeOfFieldInModelFlowItem.exec(firstSumField, modelRoot)
+
+      if (typeOfFieldToSum === "Array") {
+        groupClause.$group[tempFieldName] = { $sum: { $sum: { '$ifNull': [`$${sumField}`, 0] } } }
+      } else {
+        groupClause.$group[tempFieldName] = { $sum: { $ifNull: [`$${sumField}`, 0] } }
+      }
+      groupsClauses.push(groupClause)
+    } else {
+      groupsClauses.push(groupClause)
+    }
+
+
+    const projectClause: any = {
+      $project: {
+        _id: 1,
+        [fieldToGroup]: "$_id",
+        count: 1
+      }
+    }
+
+    if (detailed) {
+      projectClause.$project.docs = 1
+    }
+
+    if (sumField) {
+      const tempFieldName = sumField.replace(/\./g, '_')
+      projectClause.$project[`${sumField}Total`] = `$${tempFieldName}`
+    }
+
+    groupsClauses.push(projectClause)
+
+    return groupsClauses
+  }
+}
+
+export default new GroupFlowItem

package/src/flow/searcher/item/IsValidObjectIdFlowItem.ts

@@ -0,0 +1,8 @@
+class IsValidObjectIdFlowItem {
+  exec(value: string): boolean {
+    const objectIdPattern = /^[0-9a-fA-F]{24}$/;
+    return objectIdPattern.test(value);
+  }
+}
+
+export default new IsValidObjectIdFlowItem