@things-factory/shell 5.0.0-alpha.5 → 5.0.0-alpha.50

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) qb.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] }
+      }
+  }
+}