@things-factory/shell 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,200 +0,0 @@
-import { Between, Equal, FindOperator, ILike, In, IsNull, Like, Not, Raw } from 'typeorm'
-
-import { Filter, ListParam, Pagination, Sorting } from '../service/common-types'
-import { Domain } from '../service/domain/domain'
-import { adjustFilters } from './list-param-adjuster'
-
-const OPERATION_FUNCTION_MAP: { [operator: string]: (value: any) => FindOperator<any> } = {
-  search: value => ILike(value),
-  eq: value => Equal(value),
-  noteq: value => Not(Equal(value)),
-  like: value => Like(value),
-  i_like: value => ILike(value),
-  nlike: value => Not(Like(value)),
-  i_nlike: value => Not(ILike(value)),
-  lt: value => Raw(alias => `${alias} < ${typeof value === 'string' ? "'" + value + "'" : value}`),
-  gt: value => Raw(alias => `${alias} > ${typeof value === 'string' ? "'" + value + "'" : value}`),
-  lte: value => Raw(alias => `${alias} <= ${typeof value === 'string' ? "'" + value + "'" : value}`),
-  gte: value => Raw(alias => `${alias} >= ${typeof value === 'string' ? "'" + value + "'" : value}`),
-  in: value => In(value),
-  notin: value => Not(In(value)),
-  is_null: () => IsNull(),
-  is_not_null: () => Not(IsNull()),
-  is_false: () => Raw(alias => `${alias} IS FALSE`),
-  in_true: () => Raw(alias => `${alias} IS TRUE`),
-  is_not_true: () => Raw(alias => `${alias} IS NOT TRUE`),
-  is_present: () => Raw(alias => `${alias} IS PRESENT`),
-  is_blank: () => Raw(alias => `${alias} IS BLANK`),
-  is_empty_num_id: () => Raw(alias => `${alias} IS EMPTY NUMERIC ID`),
-  between: value => Between(value[0], value[1])
-}
-
-/**
- * Get the TypeORM FindOperator function for a given filter.
- * @param {Filter} filter - The filter object containing operator and value.
- * @returns {FindOperator<any>} - The corresponding FindOperator function.
- */
-function getOperatorFunction({ operator, value }: Filter): FindOperator<any> {
-  return OPERATION_FUNCTION_MAP[operator](value)
-}
-
-/**
- * Create pagination parameters for a TypeORM query.
- * @param {Pagination} pagination - The pagination object.
- * @returns {{ skip?: number; take?: number }} - The pagination parameters.
- */
-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
-    var take = 0
-
-    if (limit > 0) {
-      skip = Math.max(page - 1, 0) * limit
-      take = limit
-      Object.assign(result, {
-        skip,
-        take
-      })
-    }
-  }
-
-  return result
-}
-
-/**
- * Create sorting parameters for a TypeORM query.
- * @param {Sorting[]} sortings - The array of sorting objects.
- * @returns {{ order?: { [name: string]: 'DESC' | 'ASC' } }} - The sorting parameters.
- */
-function makeSortingParams(sortings: Sorting[]): { order?: { [name: string]: 'DESC' | 'ASC' } } {
-  var result = {} as { order?: { [name: string]: 'DESC' | 'ASC' } }
-  if (sortings) {
-    var order = {} as { [name: string]: 'DESC' | 'ASC' }
-    sortings.forEach(s => {
-      order[s.name] = s.desc ? 'DESC' : 'ASC'
-    })
-
-    Object.assign(result, {
-      order
-    })
-  }
-
-  return result
-}
-
-/**
- * Create filter parameters for a TypeORM query.
- * @param {Filter[]} filters - The array of filter objects.
- * @param {string[]} searchables - The array of searchable field names.
- * @returns {{ where: { [name: string]: FindOperator<any> } | { [name: string]: FindOperator<any> }[] }} - The filter parameters.
- */
-function makeFilterParams(
-  filters: Filter[],
-  searchables?: string[]
-): {
-  where: { [name: string]: FindOperator<any> } | { [name: string]: FindOperator<any> }[]
-} {
-  /* for where AND clauses */
-  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)) {
-            console.warn('"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> })
-
-  if (searchFilters.length === 0) {
-    return {
-      where: columnWhere
-    }
-  }
-
-  /* for fulltext searching ... OR-AND composition */
-  const searchWheres = searchFilters.map(f => {
-    return {
-      [f.name]: getOperatorFunction(f),
-      ...columnWhere
-    }
-  })
-
-  return {
-    where: searchWheres
-  }
-}
-
-/**
- * Convert ListParam object to TypeORM query parameters.
- * @param {ListParam} params - The ListParam object containing pagination, sorting, and filtering options.
- * @param {string | { domain?: string | Domain; searchables?: string[] }} options - Optional domain and searchables parameters.
- * @returns {{ where?: { [name: string]: FindOperator<any> }; order?: { [name: string]: 'DESC' | 'ASC' }; skip?: number; take?: number }} - The TypeORM query parameters.
- */
-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 (domainId) {
-    filters = adjustFilters(filters, [
-      {
-        name: 'domain',
-        operator: 'eq',
-        value: domainId
-      }
-    ])
-  }
-
-  if (pagination) Object.assign(result, makePaginationParams(pagination))
-  if (sortings) Object.assign(result, makeSortingParams(sortings))
-  if (filters) Object.assign(result, makeFilterParams(filters, searchables))
-
-  return result
-}

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

@@ -1,120 +0,0 @@
-import { Brackets } from 'typeorm'
-
-import { buildCondition } from './condition-builder'
-import { Filter, ListParam, InheritedValueType } from '../service/common-types/list-param'
-
-/**
- * @deprecated This function is recommended to be replaced with the `getQueryBuilderFromListParams` function.
- *
- * Builds a TypeORM query using the provided parameters to filter, paginate, and sort the data.
- *
- * @param {QueryBuilder} queryBuilder - The TypeORM query builder to build the query on.
- * @param {ListParam} params - The list parameters to apply to the query.
- * @param {Object} context - The context object, typically containing information about the user's domain.
- * @param {boolean|Object} options - Additional options for the query builder.
- * @param {boolean} options.domainRef - Indicates whether to include domain reference in the query.
- * @param {string[]} options.searchables - An array of searchable field names.
- */
-export const buildQuery = function (
-  queryBuilder: any,
-  params: ListParam,
-  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: Filter[] =
-    params.filters?.filter(filter => {
-      if (filter.operator === 'search') {
-        return false
-      }
-      if (filter.operator.toLowerCase().includes('like') && (!searchables || !searchables.includes(filter.name))) {
-        console.warn('"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)) {
-            console.warn('"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 domain = context?.state.domain
-
-  if (columnFilters && columnFilters.length > 0) {
-    columnFilters.forEach(filter => {
-      const condition = buildCondition(queryBuilder.alias, filter.name, filter.operator, filter.value, filter.relation, Object.keys(queryBuilder.getParameters()).length)
-
-      if (condition?.clause) queryBuilder.andWhere(condition.clause)
-      if (condition?.parameters) queryBuilder.setParameters(condition.parameters)
-    })
-  }
-
-  if (searchFilters.length > 0) {
-    queryBuilder.andWhere(
-      new Brackets(qb => {
-        searchFilters.forEach((filter, index) => {
-          const clause = `${queryBuilder.alias}.${filter.name} LIKE :${filter.name}`
-          const parameters = { [filter.name]: filter.value }
-
-          index === 0 ? qb.where(clause, parameters) : qb.orWhere(clause, parameters)
-        })
-      })
-    )
-  }
-
-  if (domainRef) {
-    const inherited = params?.inherited || InheritedValueType.None
-
-    if (!inherited || inherited == InheritedValueType.None) {
-      queryBuilder.andWhere(`${queryBuilder.alias}.domain = :domain`, { domain: domain.id })
-    } else if (inherited == InheritedValueType.Include) {
-      queryBuilder.andWhere(`${queryBuilder.alias}.domain In(:...domains)`, {
-        domains: [domain.id, domain.parentId].filter(Boolean)
-      })
-    } else if (inherited == InheritedValueType.Only) {
-      queryBuilder.andWhere(`${queryBuilder.alias}.domain = :domain`, { domain: domain.parentId || 'Impossible' })
-    } else {
-      queryBuilder.andWhere(`${queryBuilder.alias}.domain = :domain`, { domain: 'Impossible' })
-    }
-  }
-
-  if (pagination && pagination.page > 0 && pagination.limit > 0) {
-    queryBuilder.skip(pagination.limit * (pagination.page - 1))
-    queryBuilder.take(pagination.limit)
-  }
-
-  if (sortings && sortings.length > 0) {
-    sortings.forEach((sorting, index) => {
-      const sortField = sorting.name.split('.').length > 1 ? sorting.name : `${queryBuilder.alias}.${sorting.name}`
-      if (index === 0) {
-        queryBuilder.orderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
-      } else {
-        queryBuilder.addOrderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
-      }
-    })
-  }
-}

package/server/utils/publish-progress.ts

@@ -1,23 +0,0 @@
-import { pubsub } from '../pubsub'
-
-/**
- * Publishes a progress update message to the 'data' channel in the Pub/Sub system.
- *
- * @param {Object} param - The progress update parameters.
- * @param {string} param.domain - The domain or category of the progress update.
- * @param {string} param.tag - The tag or identifier for the progress update.
- * @param {number} param.progress - The progress value indicating the completion percentage.
- * @param {string} param.message - A message or description of the progress update.
- */
-export function publishProgress({ domain, tag, progress, message }) {
-  pubsub.publish('data', {
-    data: {
-      domain,
-      tag,
-      data: {
-        progress,
-        message
-      }
-    }
-  })
-}