@things-factory/shell 5.0.0-alpha.4 → 5.0.0-alpha.42

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

@@ -1,8 +1,8 @@
-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'
 
-const OPERATION_FUNCTION_MAP = {
+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 +27,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,39 +41,41 @@ 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[]): {
+  where: { [name: string]: FindOperator<any> } | { [name: string]: FindOperator<any> }[]
+} {
   /* for where AND clauses */
   const columnFilters = filters.filter(filter => filter.operator !== 'search')
   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) {
@@ -95,9 +97,19 @@ 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,
+  domain?: String
+): {
+  where?: { [name: string]: FindOperator<any> }
+  order?: {
+    [name: string]: 'DESC' | 'ASC'
+  }
+  skip?: number
+  take?: number
+} {
+  var { pagination, filters = [], sortings } = params
+  var result = {}
 
   if (domain) {
     filters.push({
@@ -107,9 +119,9 @@ export function convertListParams(params: typeof ListParam, domain?: String) {
     })
   }
 
-  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))
 
-  return jsonParams
+  return result
 }

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

@@ -1,6 +1,9 @@
-import { Brackets } from 'typeorm'
+import { Brackets, Repository, SelectQueryBuilder } from 'typeorm'
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata'
 
+import { Domain } from '../service/domain/domain'
 import { buildCondition } from './condition-builder'
+import { buildWhereClause } from './where-clause-builder'
 
 export const buildQuery = function (queryBuilder: any, params: any, context: any, domainRef: Boolean = true) {
   const columnFilters = params.filters?.filter(filter => filter.operator !== 'search') || []
@@ -58,3 +61,92 @@ export const buildQuery = function (queryBuilder: any, params: any, context: any
     })
   }
 }
+
+export function getQueryBuilderFromListParams<Type>(options: {
+  repository: Repository<Type>
+  params: any
+  domain?: Domain
+  alias?: string
+}): SelectQueryBuilder<Type> {
+  var { repository, params, domain, alias } = options
+  const selectQueryBuilder = repository.createQueryBuilder(alias)
+  alias = selectQueryBuilder.alias
+
+  const columnFilters = params.filters?.filter(filter => filter.operator !== 'search') || []
+  const searchFilters = params.filters?.filter(filter => filter.operator === 'search') || []
+  const pagination = params.pagination
+  const sortings = params.sortings
+
+  const metadata = repository.metadata
+  const columnMetas = params.filters
+    .map(filter => filter.name)
+    .reduce((sum, name) => {
+      sum[name] = metadata.columns.find(column => column.propertyName === name)
+      return sum
+    }, {} as { [name: string]: ColumnMetadata })
+
+  if (columnFilters && columnFilters.length > 0) {
+    columnFilters.forEach(filter => {
+      const { name, operator, value } = filter
+
+      const condition = buildWhereClause({
+        alias,
+        columnMeta: columnMetas[name],
+        operator,
+        value,
+        seq: Object.keys(selectQueryBuilder.getParameters()).length + 1,
+        domain,
+        selectQueryBuilder
+      })
+
+      if (condition?.clause) selectQueryBuilder.andWhere(condition.clause)
+      if (condition?.parameters) selectQueryBuilder.setParameters(condition.parameters)
+    })
+  }
+
+  if (searchFilters.length > 0) {
+    selectQueryBuilder.andWhere(
+      new Brackets(qb => {
+        searchFilters.forEach(filter => {
+          const { name, operator, value } = filter
+
+          const condition = buildWhereClause({
+            alias,
+            columnMeta: columnMetas[name],
+            operator /* has to be 'search' */,
+            value,
+            seq: Object.keys(selectQueryBuilder.getParameters()).length + 1,
+            domain,
+            selectQueryBuilder
+          })
+
+          if (condition?.clause) selectQueryBuilder.orWhere(condition.clause)
+          if (condition?.parameters) selectQueryBuilder.setParameters(condition.parameters)
+        })
+      })
+    )
+  }
+
+  if (domain) {
+    selectQueryBuilder.andWhere(`${selectQueryBuilder.alias}.domain = :domain`, { domain: domain.id })
+  }
+
+  if (pagination && pagination.page > 0 && pagination.limit > 0) {
+    selectQueryBuilder.skip(pagination.limit * (pagination.page - 1))
+    selectQueryBuilder.take(pagination.limit)
+  }
+
+  if (sortings && sortings.length > 0) {
+    sortings.forEach((sorting, index) => {
+      const sortField =
+        sorting.name.split('.').length > 1 ? sorting.name : `${selectQueryBuilder.alias}.${sorting.name}`
+      if (index === 0) {
+        selectQueryBuilder.orderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
+      } else {
+        selectQueryBuilder.addOrderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
+      }
+    })
+  }
+
+  return selectQueryBuilder
+}

package/server/utils/where-clause-builder.ts

@@ -0,0 +1,200 @@
+import { SelectQueryBuilder } from 'typeorm'
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata'
+
+import { Domain } from '../service/domain/domain'
+
+function getClause(
+  selectQueryBuilder: SelectQueryBuilder<any>,
+  columnMeta: ColumnMetadata,
+  operator: string,
+  field: string,
+  pname: string
+): string {
+  const relation = columnMeta.relationMetadata
+
+  if (!relation) {
+    switch (operator) {
+      case 'like':
+        return `${field} LIKE :${pname}`
+
+      case 'search':
+      case 'i_like':
+        return `LOWER(${field}) LIKE :${pname}`
+
+      case 'nlike':
+        return `${field} NOT LIKE :${pname}`
+
+      case 'i_nlike':
+        return `LOWER(${field}) NOT LIKE :${pname}`
+    }
+  }
+
+  const inverseEntityMetadata = relation.inverseEntityMetadata
+  const { target, tableName, ownColumns } = inverseEntityMetadata
+  var subquery = selectQueryBuilder.subQuery().select('id').from(target, tableName)
+
+  switch (operator) {
+    case 'like':
+      subquery = subquery.where(`${tableName}.name LIKE :${pname}`)
+      break
+
+    case 'search':
+    case 'i_like':
+      subquery = subquery.where(`LOWER(${tableName}.name) LIKE :${pname}`)
+      break
+
+    case 'nlike':
+      subquery = subquery.where(`${tableName}.name NOT LIKE :${pname}`)
+      break
+
+    case 'i_nlike':
+      subquery = subquery.where(`LOWER(${tableName}.name) NOT LIKE :${pname}`)
+      break
+  }
+
+  if (ownColumns.find(column => column.propertyName === 'domain')) {
+    subquery.andWhere(`${tableName}.domain_id = :domain`)
+  }
+
+  return `${field} IN ${subquery.getQuery()}`
+}
+
+export const buildWhereClause = function (options: {
+  alias: string
+  columnMeta: ColumnMetadata
+  operator: string
+  value: any
+  seq: number
+  domain: Domain
+  selectQueryBuilder: SelectQueryBuilder<any>
+}) {
+  const { alias, columnMeta, operator, value, seq, selectQueryBuilder, domain } = options
+  const values = value instanceof Array ? value : [value]
+  const { propertyName: name, propertyAliasName, propertyPath: path, databaseName } = columnMeta
+  const field = `${alias}.${databaseName}`
+  const pname = `args${seq}`
+
+  switch (operator) {
+    case 'eq':
+      return {
+        clause: `${field} = :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'like':
+      return {
+        clause: getClause(selectQueryBuilder, columnMeta, operator, field, pname),
+        parameters: { [pname]: `%${value}%` }
+      }
+
+    case 'search':
+    case 'i_like':
+      return {
+        clause: getClause(selectQueryBuilder, columnMeta, operator, field, pname),
+        parameters: { [pname]: `%${String(value).toLowerCase()}%` }
+      }
+
+    case 'nlike':
+      return {
+        clause: getClause(selectQueryBuilder, columnMeta, operator, field, pname),
+        value: { [pname]: `%${value}%` }
+      }
+
+    case 'i_nlike':
+      return {
+        clause: getClause(selectQueryBuilder, columnMeta, operator, field, pname),
+        value: { [pname]: `%${String(value).toLowerCase()}%` }
+      }
+
+    case 'lt':
+      return {
+        clause: `${field} < :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'gt':
+      return {
+        clause: `${field} > :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'lte':
+      return {
+        clause: `${field} <= :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'gte':
+      return {
+        clause: `${field} >= :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'noteq':
+      return {
+        clause: `${field} != :${pname}`,
+        parameters: { [pname]: value }
+      }
+
+    case 'in':
+      return {
+        clause: `${field} IN (:...${pname})`,
+        parameters: { [pname]: values }
+      }
+
+    case 'notin':
+      return {
+        clause: `${field} NOT IN (:...${pname})`,
+        parameters: { [pname]: values }
+      }
+
+    case 'notin_with_null':
+      return {
+        clause: `${field} IS NULL OR ${field} NOT IN (:...${pname}))`,
+        parameters: { [pname]: values }
+      }
+
+    case 'is_null':
+      return {
+        clause: `${field} IS NULL`
+      }
+    case 'is_not_null':
+      return {
+        clause: `${field} IS NOT NULL`
+      }
+    case 'is_false':
+      return {
+        clause: `${field} IS FALSE`
+      }
+    case 'is_true':
+      return {
+        clause: `${field} IS TRUE`
+      }
+    case 'is_not_false':
+      return {
+        clause: `${field} IS NOT FALSE`
+      }
+    case 'is_not_true':
+      return {
+        clause: `${field} IS NOT TRUE`
+      }
+    case 'is_present':
+      return {
+        clause: `${field} IS PRESENT`
+      }
+    case 'is_blank':
+      return {
+        clause: `${field} IS BLANK`
+      }
+    case 'is_empty_num_id':
+      return {
+        clause: `${field} IS EMPTY NUMERIC ID`
+      }
+
+    case 'between':
+      return {
+        clause: `${field} BETWEEN  :${pname}_1 AND :${pname}_2`,
+        parameters: { [`args${seq}_1`]: values[0], [`args${seq}_2`]: values[1] }
+      }
+  }
+}