c2-mongoose 2.1.319 → 2.1.321

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

@@ -0,0 +1,113 @@
+import mongoose, { Types } from "mongoose"
+import ExtractFieldsOfTypeFlowItem from "./ExtractFieldsOfTypeFlowItem"
+import IsValidObjectIdFlowItem from "./IsValidObjectIdFlowItem"
+import BuildConditionFlowItem from "./BuildConditionFlowItem"
+import BuildRegexFlowItem from "./BuildRegexFlowItem"
+import NormalizeValueFlowItem from "./NormalizeValueFlowItem"
+
+class MatchFlowItem {
+  exec(filters: any, model: mongoose.Model<any>) {
+
+    // Recuperar todos os campos do tipo String
+    const camposString = !filters.searchTextFields ? ExtractFieldsOfTypeFlowItem.exec(model.schema, 'String') : filters.searchTextFields
+
+    let andQueriesParam = {} as any
+    Object.entries(filters).forEach(([key, value]) => {
+      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.exec(value as string) && key !== 'owner' && key !== 'identifier') {
+          value = new Types.ObjectId(value as string)
+        }
+
+        if (value === 'true') {
+          value = true
+        }
+
+        if (value === 'false') {
+          value = false
+        }
+
+        const condition = BuildConditionFlowItem.exec(key, value, model)
+        andQueriesParam = { ...andQueriesParam, ...condition }
+      }
+    })
+
+    if (filters.searchText && camposString) {
+      let regex = BuildRegexFlowItem.exec(filters.searchText)
+      let conditions = { $or: [] as any }
+      for (let fieldString of camposString) {
+        let conditionAux: { [key: string]: any } = {}
+        conditionAux[fieldString] = { $regex: regex }
+
+        conditions.$or.push(conditionAux)
+      }
+      andQueriesParam = { ...andQueriesParam, ...conditions }
+    }
+
+    const orPayload: any[] = []
+    if (filters?.or) {
+      for (const clauseOr of filters?.or) {
+        let and: any
+        let conditionsAnd: any
+        Object.entries(clauseOr).forEach(([key, value]) => {
+          if (!value) return
+          value = NormalizeValueFlowItem.exec(key, value)
+          const condition = BuildConditionFlowItem.exec(key, value, model)
+
+          if (!conditionsAnd) {
+            conditionsAnd = {}
+          }
+          conditionsAnd = { ...conditionsAnd, ...condition }
+        })
+
+        if (conditionsAnd) {
+          and = { $and: [conditionsAnd] }
+        }
+
+        if (and) {
+          orPayload.push(and)
+        }
+      }
+    }
+
+    let filtersFinal = { ...andQueriesParam } as any
+
+    if (orPayload.length > 0) {
+      if (!filtersFinal.$or) filtersFinal.$or = []
+      filtersFinal.$or = [...filtersFinal.$or, ...orPayload]
+    }
+
+
+    return filtersFinal
+
+  }
+}
+
+export default new MatchFlowItem;

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

@@ -0,0 +1,22 @@
+import { Types } from "mongoose"
+import IsValidObjectIdFlowItem from "./IsValidObjectIdFlowItem"
+
+class NormalizeValueFlowItem {
+  exec(key: string, value: any) {
+    if (typeof value === 'string' && IsValidObjectIdFlowItem.exec(value as string) && key !== 'owner') {
+      value = new Types.ObjectId(value as string)
+    }
+
+    if (value === 'true') {
+      value = true
+    }
+
+    if (value === 'false') {
+      value = false
+    }
+
+    return value
+  }
+}
+
+export default new NormalizeValueFlowItem

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

@@ -0,0 +1,99 @@
+import mongoose from "mongoose";
+
+class PopulateFlowItem {
+  exec(populate = [], modelRoot: mongoose.Model<any>): any[] {
+    let populateClauses: any[] = []
+    populate.forEach((populateField: string) => {
+      let [first, ...rest] = populateField.split('.')
+
+
+      let fieldDefinition = modelRoot.schema.path(first);
+      let typeFirst = fieldDefinition.instance
+
+      if (typeFirst === 'Array') {
+        if (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: ${populateField}`);
+      }
+
+      let modelName = fieldDefinition.options.ref;
+      let refModel = mongoose.model(modelName);
+      let collectionName = refModel.collection.name;
+
+      if (!populateClauses.some((populateClause: any) => populateClause?.$lookup?.localField === first)) {
+        const populateClauseLookup: any[] = [
+          {
+            $lookup: {
+              from: collectionName, // The collection where user data is stored
+              localField: first,
+              foreignField: "_id",
+              as: first
+            }
+          },
+        ]
+        if (typeFirst !== 'Array') {
+          populateClauseLookup.push(
+            {
+              $addFields: {
+                [`${first}`]: { $ifNull: [{ $arrayElemAt: [`$${first}`, 0] }, undefined] },
+              }
+            }
+          )
+        }
+
+        populateClauses = [...populateClauses, ...populateClauseLookup]
+      }
+
+      if (rest?.length > 0) {
+        let pathRelativeCurrent = first
+        for (const nextField of rest) {
+          pathRelativeCurrent += `.${nextField}`
+          if (populateClauses.some((populateClause: any) => populateClause?.$lookup?.localField.startsWith(pathRelativeCurrent))) {
+            break
+          }
+          fieldDefinition = refModel.schema.path(nextField);
+
+          if (!fieldDefinition || !fieldDefinition.options || !fieldDefinition.options.ref) {
+            throw new Error(`[1]No reference found for populate field: ${populateField}`);
+          }
+          modelName = fieldDefinition.options.ref;
+          refModel = mongoose.model(modelName);
+          collectionName = refModel.collection.name;
+
+          const populateClauseLookup: any = [
+            {
+              $lookup: {
+                from: collectionName,
+                localField: pathRelativeCurrent,
+                foreignField: "_id",
+                as: pathRelativeCurrent
+              }
+            }
+          ]
+          if (typeFirst !== 'Array') {
+            populateClauseLookup.push(
+              {
+                $addFields: {
+                  [`${pathRelativeCurrent}`]: { $ifNull: [{ $arrayElemAt: [`$${pathRelativeCurrent}`, 0] }, undefined] },
+                }
+              }
+            )
+          }
+
+          populateClauses = [...populateClauses, ...populateClauseLookup]
+        }
+        return
+      }
+    })
+
+    return populateClauses
+  }
+}
+
+export default new PopulateFlowItem

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

@@ -0,0 +1,34 @@
+class ProjectFlowItem {
+  exec(select: any[] = []): any {
+    const nested = (projectCurrent: any, field: string, include: boolean) => {
+      let [first, ...rest] = field.split('.')
+
+      if (rest.length === 0) {
+        projectCurrent[first] = include ? 1 : 0
+        return projectCurrent
+      }
+
+      projectCurrent[first] = {
+        ...projectCurrent[first],
+        ...nested(projectCurrent[first] || {}, rest.join("."), include)
+      }
+      return projectCurrent
+    }
+
+    if (!select?.length) return []
+
+    let selectClauses = {
+      $project: {}
+    }
+
+    select.forEach((selectField: string) => {
+      let include = selectField.startsWith("-") ? false : true
+      selectField = selectField.replace("-", "")
+      selectClauses.$project = nested(selectClauses.$project, selectField, include)
+    })
+
+    return [selectClauses]
+  }
+}
+
+export default new ProjectFlowItem

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

@@ -0,0 +1,9 @@
+class SortFlowItem {
+  exec(orderBy: string, orderSense: string): any[] {
+    let sort = {} as any
+    sort[orderBy] = orderSense === "desc" ? -1 : 1
+    return [{ $sort: sort }]
+  }
+}
+
+export default new SortFlowItem

package/src/index.ts

@@ -9,6 +9,7 @@ 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"
@@ -17,5 +18,5 @@ import { initialize } from "./utils/Utils"
 
 (global as any).LoggerRepository = undefined
 
-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 }