@things-factory/shell 5.0.0-alpha.7 → 5.0.0-y.0

package/server/utils/list-params-converter.ts

@@ -1,8 +1,11 @@
-import { Between, Equal, ILike, In, IsNull, Like, Not, Raw } from 'typeorm'
+import { Between, Equal, FindOperator, ILike, In, IsNull, Like, Not, Raw } from 'typeorm'
 
-import { ListParam } from '../service/common-types'
+import { Filter, ListParam, Pagination, Sorting } from '../service/common-types'
+import { Domain } from '../service/domain/domain'
 
-const OPERATION_FUNCTION_MAP = {
+const debug = require('debug')('things-factory:shell:list-params-converter')
+
+const OPERATION_FUNCTION_MAP: { [operator: string]: (value: any) => FindOperator<any> } = {
   search: value => ILike(value),
   eq: value => Equal(value),
   noteq: value => Not(Equal(value)),
@@ -27,12 +30,12 @@ const OPERATION_FUNCTION_MAP = {
   between: value => Between(value[0], value[1])
 }
 
-function getOperatorFunction({ operator, name, value, dataType }) {
+function getOperatorFunction({ operator, value }: { operator: string; value: any }): FindOperator<any> {
   return OPERATION_FUNCTION_MAP[operator](value)
 }
 
-function makePaginationParams(pagination) {
-  var jsonParams = {}
+function makePaginationParams(pagination: Pagination): { skip?: number; take?: number } {
+  var result = {} as { skip?: number; take?: number }
   if (pagination) {
     var { page = 0, limit = 0 } = pagination
     var skip = 0
@@ -41,41 +44,69 @@ function makePaginationParams(pagination) {
     if (limit > 0) {
       skip = Math.max(page - 1, 0) * limit
       take = limit
-      Object.assign(jsonParams, {
+      Object.assign(result, {
         skip,
         take
       })
     }
   }
 
-  return jsonParams
+  return result
 }
 
-function makeSortingParams(sortings) {
-  var jsonParams = {}
+function makeSortingParams(sortings: Sorting[]): { order?: { [name: string]: 'DESC' | 'ASC' } } {
+  var result = {} as { order?: { [name: string]: 'DESC' | 'ASC' } }
   if (sortings) {
-    var order = {}
+    var order = {} as { [name: string]: 'DESC' | 'ASC' }
     sortings.forEach(s => {
       order[s.name] = s.desc ? 'DESC' : 'ASC'
     })
 
-    Object.assign(jsonParams, {
+    Object.assign(result, {
       order
     })
   }
 
-  return jsonParams
+  return result
 }
 
-function makeFilterParams(filters) {
+function makeFilterParams(
+  filters: Filter[],
+  searchables?: string[]
+): {
+  where: { [name: string]: FindOperator<any> } | { [name: string]: FindOperator<any> }[]
+} {
   /* for where AND clauses */
-  const columnFilters = filters.filter(filter => filter.operator !== 'search')
+  const columnFilters =
+    filters?.filter(filter => {
+      if (filter.operator === 'search') {
+        return false
+      }
+      if (filter.operator.toLowerCase().includes('like') && (!searchables || !searchables.includes(filter.name))) {
+        return false
+      }
+      return true
+    }) || []
+
+  const searchFilters =
+    searchables instanceof Array
+      ? filters?.filter(filter => {
+          if (filter.operator !== 'search') {
+            return false
+          }
+          if (!searchables.includes(filter.name)) {
+            debug('"searchables" setting is required for like searches with a heavy database query load', filter.name)
+            return false
+          }
+          return true
+        }) || []
+      : []
+
   const columnWhere = columnFilters.reduce((where, f) => {
     where[f.name] = getOperatorFunction(f)
     return where
-  }, {})
+  }, {} as { [name: string]: FindOperator<any> })
 
-  const searchFilters = filters.filter(filter => filter.operator === 'search')
   if (searchFilters.length === 0) {
     return {
       where: columnWhere
@@ -95,21 +126,47 @@ function makeFilterParams(filters) {
   }
 }
 
-export function convertListParams(params: typeof ListParam, domain?: String) {
-  var { pagination, filters = [], sortings } = params as any
-  var jsonParams = {}
+export function convertListParams(
+  params: ListParam,
+  options?:
+    | string
+    | {
+        domain?: string | Domain
+        searchables?: string[]
+      }
+): {
+  where?: { [name: string]: FindOperator<any> }
+  order?: {
+    [name: string]: 'DESC' | 'ASC'
+  }
+  skip?: number
+  take?: number
+} {
+  var domainId: string | undefined
+
+  if (options) {
+    if (typeof options === 'string' /* for 하위 호환성 */) {
+      var domainId = options
+    } else {
+      var { domain, searchables } = options
+      var domainId = typeof domain === 'string' ? domain : domain?.id
+    }
+  }
+
+  var { pagination, filters = [], sortings } = params
+  var result = {}
 
-  if (domain) {
+  if (domainId) {
     filters.push({
       name: 'domain',
       operator: 'eq',
-      value: domain
+      value: domainId
     })
   }
 
-  if (pagination) Object.assign(jsonParams, makePaginationParams(pagination))
-  if (sortings) Object.assign(jsonParams, makeSortingParams(sortings))
-  if (filters) Object.assign(jsonParams, makeFilterParams(filters))
+  if (pagination) Object.assign(result, makePaginationParams(pagination))
+  if (sortings) Object.assign(result, makeSortingParams(sortings))
+  if (filters) Object.assign(result, makeFilterParams(filters, searchables))
 
-  return jsonParams
+  return result
 }

package/server/utils/list-query-builder.ts

@@ -2,9 +2,56 @@ import { Brackets } from 'typeorm'
 
 import { buildCondition } from './condition-builder'
 
-export const buildQuery = function (queryBuilder: any, params: any, context: any, domainRef: Boolean = true) {
-  const columnFilters = params.filters?.filter(filter => filter.operator !== 'search') || []
-  const searchFilters = params.filters?.filter(filter => filter.operator === 'search') || []
+const debug = require('debug')('things-factory:shell:list-query-builder')
+
+/**
+ * @deprecated The name of this function does not imply an exact purpose and it is not possible to correspond to a foreign key using the meta information of the table column, so it is recommended to replace it with the A function.
+ */
+export const buildQuery = function (
+  queryBuilder: any,
+  params: any,
+  context: any,
+  options?:
+    | boolean
+    | {
+        domainRef?: boolean
+        searchables?: string[]
+      }
+) {
+  /* default value of domainRef is 'true' */
+  var domainRef = typeof options === 'boolean' ? options : true
+
+  /* for backwards compatibility of function spec */
+  if (typeof options === 'object') {
+    var { domainRef = true, searchables } = options
+  }
+
+  const columnFilters =
+    params.filters?.filter(filter => {
+      if (filter.operator === 'search') {
+        return false
+      }
+      if (filter.operator.toLowerCase().includes('like') && (!searchables || !searchables.includes(filter.name))) {
+        debug('"searchables" setting is required for like searches with a heavy database query load', filter.name)
+        return false
+      }
+      return true
+    }) || []
+
+  const searchFilters =
+    searchables instanceof Array
+      ? params.filters?.filter(filter => {
+          if (filter.operator !== 'search') {
+            return false
+          }
+          if (!searchables.includes(filter.name)) {
+            debug('"searchables" setting is required for like searches with a heavy database query load', filter.name)
+            return false
+          }
+          return true
+        }) || []
+      : []
+
   const pagination = params.pagination
   const sortings = params.sortings
   const domainId = context && context.state.domain && context.state.domain.id