@things-factory/shell 5.0.0-alpha.9 → 5.0.0-zeta.1

package/server/pubsub.ts

@@ -4,7 +4,7 @@ import { PubSub } from 'graphql-subscriptions'
 import Redis from 'ioredis'
 import { connect } from 'mqtt'
 
-import { config } from '@things-factory/env'
+import { config, logger } from '@things-factory/env'
 
 const { middleware, host, port, nodes, topic, options } = config.get('pubsub', {})
 
@@ -56,7 +56,7 @@ switch (middleware) {
         ...options
       })
     } catch (e) {
-      console.error('graphql-kafka-subscriptions module is not installed, so application can not go further.')
+      logger.error('graphql-kafka-subscriptions module is not installed, so application can not go further.')
       throw e
     }
     break
@@ -73,7 +73,7 @@ const exitHandler = async evt => {
     try {
       await pubsub.close()
     } catch (err) {
-      console.error(err)
+      logger.error(err)
     }
   }
 }

package/server/server-dev.ts

@@ -1,33 +1,36 @@
+/* following lines should be located in top of the file */
 // @prettier-ignore
 process.env.NODE_ENV = 'development'
 process.setMaxListeners(0)
-/** Never move following lines */
 
-import { ConnectionContext, SubscriptionServer } from 'subscriptions-transport-ws'
-import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
-import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter } from './routers'
-import { execute, subscribe } from 'graphql'
-
-import { ApolloServer } from 'apollo-server-koa'
+/* following lines should be located in top of the file */
 import { ApolloServerPluginLandingPageGraphQLPlayground } from 'apollo-server-core'
-import { GraphqlLocalClient } from './graphql-local-client'
-import Koa from 'koa'
+import { ApolloServer } from 'apollo-server-koa'
+import bytesFormat from 'bytes'
 import co from 'co'
-import compose from 'koa-compose'
-import cors from '@koa/cors'
-import { createServer } from 'http'
-import { databaseInitializer } from './initializers/database'
+import { execute, subscribe } from 'graphql'
 import { graphqlUploadKoa } from 'graphql-upload'
-import { historyApiFallback } from 'koa2-connect-history-api-fallback'
-import ip from 'koa-ip'
+import { createServer } from 'http'
+import Koa from 'koa'
 import koaBodyParser from 'koa-bodyparser'
+import compose from 'koa-compose'
+import ip from 'koa-ip'
 import koaStatic from 'koa-static'
+import { historyApiFallback } from 'koa2-connect-history-api-fallback'
+/** Never move following lines */
+import { ConnectionContext, SubscriptionServer } from 'subscriptions-transport-ws'
+
 import koaWebpack from '@hatiolab/koa-webpack'
+import cors from '@koa/cors'
+import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
+
+import { GraphqlLocalClient } from './graphql-local-client'
+import { databaseInitializer } from './initializers/database'
+import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter } from './routers'
 import { schema } from './schema'
-import bytesFormat from 'bytes'
 
 process.on('uncaughtException', error => {
-  console.error(error)
+  logger.error(error)
 
   process.exit(1)
 })

package/server/server.ts

@@ -1,29 +1,31 @@
+// @prettier-ignore
 process.env.NODE_ENV = 'production'
 process.setMaxListeners(0)
 
-import { ConnectionContext, SubscriptionServer } from 'subscriptions-transport-ws'
-import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
-import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter } from './routers'
-import { execute, subscribe } from 'graphql'
-
 import { ApolloServer } from 'apollo-server-koa'
-import { GraphqlLocalClient } from './graphql-local-client'
-import Koa from 'koa'
+import bytesFormat from 'bytes'
 import co from 'co'
-import compose from 'koa-compose'
-import cors from '@koa/cors'
-import { createServer } from 'http'
-import { databaseInitializer } from './initializers/database'
+import { execute, subscribe } from 'graphql'
 import { graphqlUploadKoa } from 'graphql-upload'
-import { historyApiFallback } from 'koa2-connect-history-api-fallback'
-import ip from 'koa-ip'
+import { createServer } from 'http'
+import Koa from 'koa'
 import koaBodyParser from 'koa-bodyparser'
+import compose from 'koa-compose'
+import ip from 'koa-ip'
 import koaStatic from 'koa-static'
+import { historyApiFallback } from 'koa2-connect-history-api-fallback'
+import { ConnectionContext, SubscriptionServer } from 'subscriptions-transport-ws'
+
+import cors from '@koa/cors'
+import { config, loader, logger, orderedModuleNames } from '@things-factory/env'
+
+import { GraphqlLocalClient } from './graphql-local-client'
+import { databaseInitializer } from './initializers/database'
+import { domainPrivateRouter, domainPublicRouter, globalPrivateRouter, globalPublicRouter } from './routers'
 import { schema } from './schema'
-import bytesFormat from 'bytes'
 
 process.on('uncaughtException', error => {
-  console.error(error)
+  logger.error(error)
 
   process.exit(1)
 })

package/server/service/domain/domain-resolver.ts

@@ -22,7 +22,11 @@ export class DomainResolver {
   @Query(returns => DomainList, { description: 'To fetch multiple domain' })
   async domains(@Args() params: ListParam, @Ctx() context): Promise<DomainList> {
     const queryBuilder = getRepository(Domain).createQueryBuilder()
-    buildQuery(queryBuilder, params || {}, context, false)
+
+    buildQuery(queryBuilder, params || {}, context, {
+      domainRef: false,
+      searchables: ['name', 'description', 'subdomain']
+    })
     const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }

package/server/service/domain/domain.ts

@@ -1,12 +1,47 @@
-import { Column, CreateDateColumn, Entity, Index, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+import { Column, CreateDateColumn, Entity, Index, UpdateDateColumn } from 'typeorm'
 import { ObjectType, Field, ID } from 'type-graphql'
+import { config } from '@things-factory/env'
+
+const numericTypes = ["int","int2","int4","int8","integer","tinyint","smallint","mediumint","bigint"]
+const generatedStrategy = ['uuid','rowid',"increment","identity"]
+const domainPrimaryOption =config.get('domainPrimaryOption')
+const domainPrimaryType = domainPrimaryOption?.type
+const domainPrimaryStrategy = domainPrimaryOption?.strategy
 
 @Entity()
 @Index('ix_domain_0', (domain: Domain) => [domain.subdomain], { unique: true })
 @ObjectType()
 export class Domain {
   @Field(type => ID)
-  @PrimaryGeneratedColumn('uuid')
+  @Column(
+    domainPrimaryOption?
+    {
+      type: domainPrimaryType,
+      primary:true,
+      transformer: {
+        //from(value: DatabaseType): EntityType
+        from: (value) => {
+          return value
+        },
+        //to(value: EntityType): DatabaseType
+        to: (value) => {
+          if(!value){
+            value = 0
+          }
+          if(numericTypes.indexOf(domainPrimaryType)>=0){
+            return parseInt(value)
+          }else{
+            return value
+          }
+        }
+      },
+      generated:generatedStrategy.indexOf(domainPrimaryStrategy)>=0?domainPrimaryStrategy:false
+    }:{
+      type: 'uuid',
+      primary:true,
+      generated:'uuid'
+    }
+  )
   readonly id: string
 
   @Field()

package/server/utils/condition-builder.ts

@@ -5,12 +5,13 @@ export const buildCondition = function (
   fieldName: string,
   operator: string,
   value: any,
-  relation: boolean,
+  relation: boolean | string,
   seq: number
 ) {
   seq++
 
   fieldName = _.snakeCase(fieldName)
+  const values = value instanceof Array ? value : [value]
 
   switch (operator) {
     case 'eq':
@@ -75,24 +76,23 @@ export const buildCondition = function (
       }
 
     case 'in':
-      const clause = relation ? `${fieldName}.id IN (:...args${seq})` : `${alias}.${fieldName} IN (:...args${seq})`
-      value = value?.length ? value : [value]
       return {
-        clause,
-        parameters: { [`args${seq}`]: value }
+        clause: relation ? `${fieldName}.id IN (:...args${seq})` : `${alias}.${fieldName} IN (:...args${seq})`,
+        parameters: { [`args${seq}`]: values }
       }
+
     case 'notin':
-      value = value?.length ? value : [value]
       return {
-        clause: `${alias}.${fieldName} NOT IN (:...args${seq})`,
-        parameters: { [`args${seq}`]: value }
+        clause: relation ? `${fieldName}.id NOT IN (:...args${seq})` : `${alias}.${fieldName} NOT IN (:...args${seq})`,
+        parameters: { [`args${seq}`]: values }
       }
 
     case 'notin_with_null':
-      value = value?.length ? value : [value]
       return {
-        clause: `(${alias}.${fieldName} IS NULL OR ${alias}.${fieldName} NOT IN (:...args${seq}))`,
-        parameters: { [`args${seq}`]: value }
+        clause: relation
+          ? `(${fieldName}.id IS NULL OR ${fieldName}.id  NOT IN (:...args${seq})`
+          : `${alias}.${fieldName} IS NULL OR ${alias}.${fieldName} NOT IN (:...args${seq}))`,
+        parameters: { [`args${seq}`]: values }
       }
 
     case 'is_null':
@@ -135,7 +135,7 @@ export const buildCondition = function (
     case 'between':
       return {
         clause: `${alias}.${fieldName} BETWEEN  :args${seq}_1 AND :args${seq}_2`,
-        parameters: { [`args${seq}_1`]: value[0], [`args${seq}_2`]: value[1] }
+        parameters: { [`args${seq}_1`]: values[0], [`args${seq}_2`]: values[1] }
       }
   }
 }

package/server/utils/get-query-builder-from-list-params.ts

@@ -0,0 +1,291 @@
+import { Filter, ListParam } from 'server/service'
+import { Brackets, EntityMetadata, Repository, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm'
+
+import { Domain } from '../service/domain/domain'
+
+const debug = require('debug')('things-factory:shell:get-query-builder-from-list-params')
+
+/**
+ *
+ * @param options
+ * @returns
+ */
+export function getQueryBuilderFromListParams<Type>(options: {
+  repository: Repository<Type>
+  params: ListParam
+  domain?: Domain
+  alias?: string
+  searchables?: string[]
+  filtersMap?: { [name: string]: { columnName: string; relationColumn?: string } }
+}): SelectQueryBuilder<Type> {
+  var { repository, params, domain, alias, searchables, filtersMap = {} } = options
+
+  const selectQueryBuilder = repository.createQueryBuilder(alias)
+  const entityAlias = selectQueryBuilder.alias
+
+  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 metadata = repository.metadata
+
+  if (columnFilters && columnFilters.length > 0) {
+    columnFilters.forEach(filter => {
+      addCondition(metadata, selectQueryBuilder, selectQueryBuilder, filter, filtersMap, true)
+    })
+  }
+
+  if (searchFilters.length > 0) {
+    selectQueryBuilder.andWhere(
+      new Brackets(qb => {
+        searchFilters.forEach(filter => {
+          addCondition(metadata, selectQueryBuilder, qb, filter, filtersMap, false)
+        })
+      })
+    )
+  }
+
+  if (domain) {
+    selectQueryBuilder.andWhere(`${entityAlias}.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 : `${entityAlias}.${sorting.name}`
+      if (index === 0) {
+        selectQueryBuilder.orderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
+      } else {
+        selectQueryBuilder.addOrderBy(sortField, sorting.desc ? 'DESC' : 'ASC')
+      }
+    })
+  }
+
+  return selectQueryBuilder
+}
+
+function addCondition<T>(
+  metadata: EntityMetadata,
+  selectQueryBuilder: SelectQueryBuilder<T>,
+  whereExpressionBuilder: WhereExpressionBuilder,
+  filter: Filter,
+  filtersMap: { [name: string]: { columnName: string; relationColumn?: string } } = {},
+  andCondition: boolean
+): void {
+  const { name, operator, value } = filter
+  const values = value instanceof Array ? value : [value]
+  const entityAlias = selectQueryBuilder.alias
+
+  var { relationColumn, columnName } = filtersMap[name] || {}
+  /*
+    1. relationColumn과 columnName이 지정된 경우 
+    - relation inverse 테이블에서, columnName을 찾는다.
+    2. relationColumn만 지정된 경우는 없어야 한다.
+    - 이 경우 columnName 은 'name' 이라고 판단한다.
+    3. columnName이 지정된 경우.
+    - 이 경우는 columnName 만 적용한다.
+  */
+  if (relationColumn) {
+    var relationColumnMeta = metadata.columns.find(column => column.propertyName === relationColumn)
+    if (!relationColumnMeta) {
+      debug(`relationColumn "${relationColumn}" in filtersMap for "${name}" is not a relation column`)
+      return
+    }
+
+    var relation = relationColumnMeta.relationMetadata
+    var entityMetadata = relation.inverseEntityMetadata
+    var columnMeta = entityMetadata.columns.find(column => column.propertyName === (columnName || 'name'))
+    if (!columnMeta) {
+      debug(`columnName "${columnName}" in filtersMap for "${name}" is not a column`)
+      return
+    }
+  } else {
+    var columnMeta = metadata.columns.find(column => column.propertyName === (columnName || name))
+    if (!columnMeta) {
+      /* relationId 에 대한 필터링은 해당 컬럼값 자체의 비교로 한다. */
+      var relationIdMeta = metadata.relationIds.find(relationId => relationId.propertyName === (columnName || name))
+      if (relationIdMeta) {
+        columnMeta = relationIdMeta.relation.joinColumns[0]
+      } else {
+        columnName
+          ? debug(`columnName "${columnName}" in filtersMap for "${name}" is not a column`)
+          : debug(`name "${name}" is not a column`)
+      }
+    } else {
+      var relation = columnMeta.relationMetadata
+    }
+
+    if (relation) {
+      /* filterMap에 의해서 relationColumn 이 지정되지 않았더라도, name 또는 columnName의 column이 relation인 경우에는
+        - 조건절 구성을 위한 타겟필드명은 'name' 으로만 한정된다.
+      */
+      var relationColumnMeta = columnMeta
+      var entityMetadata = relation.inverseEntityMetadata
+      columnMeta = entityMetadata.columns.find(column => column.propertyName === 'name')
+      if (!columnMeta) {
+        debug(`relation column "${columnName || name}" does not have "name" column`)
+        return
+      }
+    }
+  }
+
+  const dbNameForColumn = columnMeta.databaseName
+  const alias = relationColumnMeta ? `${name}-filter` : entityAlias
+
+  /* relation columne인 경우 name을 alias로 사용한다. */
+  const field = `${alias}.${dbNameForColumn}`
+
+  var clause = ''
+  var parameters = {}
+
+  switch (operator) {
+    case 'eq':
+      clause = `${field} = :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'like':
+      clause = `${field} LIKE :${name}`
+      parameters = { [name]: `%${value}%` }
+      break
+
+    case 'search':
+    case 'i_like':
+      clause = `LOWER(${field}) LIKE :${name}`
+      parameters = { [name]: `%${String(value).toLowerCase()}%` }
+      break
+
+    case 'nlike':
+      clause = `${field} NOT LIKE :${name}`
+      parameters = { [name]: `%${value}%` }
+      break
+
+    case 'i_nlike':
+      clause = `LOWER(${field}) NOT LIKE :${name}`
+      parameters = { [name]: `%${String(value).toLowerCase()}%` }
+      break
+
+    case 'lt':
+      clause = `${field} < :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'gt':
+      clause = `${field} > :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'lte':
+      clause = `${field} <= :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'gte':
+      clause = `${field} >= :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'noteq':
+      clause = `${field} != :${name}`
+      parameters = { [name]: value }
+      break
+
+    case 'in':
+      clause = `${field} IN (:...${name})`
+      parameters = { [name]: values }
+      break
+
+    case 'notin':
+      clause = `${field} NOT IN (:...${name})`
+      parameters = { [name]: values }
+      break
+
+    case 'notin_with_null':
+      clause = `${field} IS NULL OR ${field} NOT IN (:...${name}))`
+      parameters = { [name]: values }
+      break
+
+    case 'is_null':
+      clause = `${field} IS NULL`
+      break
+
+    case 'is_not_null':
+      clause = `${field} IS NOT NULL`
+      break
+
+    case 'is_false':
+      clause = `${field} IS FALSE`
+      break
+
+    case 'is_true':
+      clause = `${field} IS TRUE`
+      break
+
+    case 'is_not_false':
+      clause = `${field} IS NOT FALSE`
+      break
+
+    case 'is_not_true':
+      clause = `${field} IS NOT TRUE`
+      break
+
+    case 'is_present':
+      clause = `${field} IS PRESENT`
+      break
+
+    case 'is_blank':
+      clause = `${field} IS BLANK`
+      break
+
+    case 'is_empty_num_id':
+      clause = `${field} IS EMPTY NUMERIC ID`
+      break
+
+    case 'between':
+      clause = `${field} BETWEEN  :${name}_1 AND :${name}_2`
+      parameters = { [`${name}_1`]: values[0], [`${name}_2`]: values[1] }
+      break
+  }
+
+  if (relationColumnMeta) {
+    const { propertyName } = relationColumnMeta
+    const property = `${entityAlias}.${propertyName}`
+    if (andCondition) {
+      selectQueryBuilder.innerJoin(property, alias, clause, parameters)
+    } else {
+      selectQueryBuilder.leftJoin(property, alias)
+      whereExpressionBuilder.orWhere(clause, parameters)
+    }
+  } else {
+    andCondition
+      ? whereExpressionBuilder.andWhere(clause, parameters)
+      : whereExpressionBuilder.orWhere(clause, parameters)
+  }
+}

package/server/utils/index.ts

@@ -3,3 +3,5 @@ export * from './condition-builder'
 export * from './list-query-builder'
 export * from './list-params-converter'
 export * from './publish-progress'
+export * from './get-query-builder-from-list-params'
+export * from './list-param-adjuster'

package/server/utils/list-param-adjuster.ts

@@ -0,0 +1,12 @@
+import { Filter } from '../service/common-types'
+
+export function adjustFilters(filters: Filter[], filtersChange: Filter[]): Filter[] {
+  var filtersNew = [...filters]
+
+  filtersChange.forEach(change => {
+    const idx = (filtersNew || []).findIndex(f => f.name === change.name)
+    idx !== -1 ? filtersNew.splice(idx, 1, change) : filtersNew.push(change)
+  })
+
+  return filtersNew
+}