@things-factory/shell 5.0.15 → 6.0.0-alpha.12

package/server/server.ts

@@ -113,9 +113,13 @@ const bootstrap = async () => {
         var { extra, connectionParams } = ctx
         var { request } = extra
 
-        var url = new URL(((connectionParams['headers'] as any) || connectionParams).referer)
-        var accessToken = url.searchParams.get('access_token')
-        connectionParams['headers']['authorization'] = accessToken
+        if (((connectionParams['headers'] as any) || connectionParams)?.referer) {
+          var url = new URL(((connectionParams['headers'] as any) || connectionParams).referer)
+          var accessToken = url.searchParams.get('access_token')
+          if (accessToken) {
+            connectionParams['headers']['authorization'] = accessToken
+          }
+        }
 
         request.headers = {
           ...request.headers,
@@ -198,11 +202,7 @@ const bootstrap = async () => {
   app.use(koaBodyParser(bodyParserOption))
   app.use(graphqlUploadKoa(fileUploadOption))
 
-  app.use(
-    server.getMiddleware({
-      path: '/graphql'
-    })
-  )
+  server.applyMiddleware({ app, path: '/graphql' })
 
   /* routers */
   process.emit('bootstrap-module-global-public-route' as any, app, globalPublicRouter)

package/server/service/common-types/list-param.ts

@@ -1,4 +1,5 @@
-import { ArgsType, InputType, Field, Int } from 'type-graphql'
+import { ArgsType, Field, InputType, Int } from 'type-graphql'
+
 import { ScalarAny } from './scalar-any'
 
 @InputType()
@@ -27,8 +28,8 @@ export class Filter {
   @Field()
   operator: string
 
-  @Field(type => ScalarAny)
-  value: any
+  @Field(type => ScalarAny, { nullable: true })
+  value?: any
 
   @Field({ nullable: true })
   relation?: boolean

package/server/service/directive-transaction/transaction.ts

@@ -1,9 +1,10 @@
 import { defaultFieldResolver, GraphQLSchema } from 'graphql'
 import gql from 'graphql-tag'
-import { getConnection } from 'typeorm'
 
 import { getDirective, MapperKind, mapSchema } from '@graphql-tools/utils'
 
+import { getDataSource } from '../../initializers/database'
+
 const DIRECTIVE = 'transaction'
 
 export const transactionDirectiveTypeDefs = gql`
@@ -17,7 +18,7 @@ export const transactionDirectiveResolver = (schema: GraphQLSchema) =>
         const { resolve = defaultFieldResolver } = fieldConfig
 
         fieldConfig.resolve = async function (source, args, context, info) {
-          return await getConnection().transaction(async tx => {
+          return await getDataSource('tx').transaction(async tx => {
             /* local-graphql-client로부터 invoke인 경우에는 context.req, context.res 가 없으므로, 빈 오브젝트로 대체해준다. */
             let wrap = context.app.createContext(context.req || {}, context.res || {})
 

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

@@ -1,8 +1,9 @@
 import { Arg, Args, Ctx, Directive, Mutation, Query, Resolver } from 'type-graphql'
-import { getRepository, In, Repository } from 'typeorm'
+import { In, Repository } from 'typeorm'
 
 import { slugger } from '@things-factory/utils'
 
+import { getRepository } from '../../initializers/database'
 import { buildQuery } from '../../utils/list-query-builder'
 import { ListParam } from '../common-types/list-param'
 import { Domain } from './domain'
@@ -15,12 +16,12 @@ export class DomainResolver {
   async domain(@Arg('id') id: string): Promise<Domain> {
     const repository = getRepository(Domain)
 
-    return await repository.findOne({ id })
+    return await repository.findOneBy({ id })
   }
 
   @Directive('@privilege(category: "system", privilege: "query", superUserGranted: true)')
   @Query(returns => DomainList, { description: 'To fetch multiple domain' })
-  async domains(@Args() params: ListParam, @Ctx() context): Promise<DomainList> {
+  async domains(@Args() params: ListParam, @Ctx() context: any): Promise<DomainList> {
     const queryBuilder = getRepository(Domain).createQueryBuilder()
 
     buildQuery(queryBuilder, params || {}, context, {
@@ -37,7 +38,7 @@ export class DomainResolver {
     const domainRepository: Repository<Domain> = getRepository(Domain)
     const targetSubdomain: string = slugger(name)
 
-    const oldDomain = await domainRepository.findOne({ subdomain: targetSubdomain })
+    const oldDomain = await domainRepository.findOneBy({ subdomain: targetSubdomain })
     if (oldDomain) {
       throw new Error('domain is duplicated')
     }
@@ -52,7 +53,7 @@ export class DomainResolver {
     const domainRepo: Repository<Domain> = getRepository(Domain)
     const subdomain: string = slugger(name)
 
-    const domain: Domain = await domainRepo.findOne({ subdomain })
+    const domain: Domain = await domainRepo.findOneBy({ subdomain })
     if (domain) {
       throw new Error('domain is duplicated')
     }
@@ -79,7 +80,7 @@ export class DomainResolver {
   @Mutation(returns => Domain, { description: 'To update domain' })
   async updateDomain(@Arg('name') name: string, @Arg('patch', () => DomainPatch) patch: DomainPatch) {
     const repository = getRepository(Domain)
-    const domain: Domain = await repository.findOne({ name })
+    const domain: Domain = await repository.findOneBy({ name })
 
     return await repository.save({
       ...domain,

package/server/utils/get-domain.ts

@@ -1,9 +1,9 @@
-import { getRepository } from 'typeorm'
 import { URL } from 'url'
 
 import { config } from '@things-factory/env'
 import { getPathInfo } from '@things-factory/utils'
 
+import { getRepository } from '../initializers/database'
 import { Domain } from '../service/domain/domain'
 
 const useVirtualHostBasedDomain = !!config.get('useVirtualHostBasedDomain')
@@ -72,7 +72,7 @@ export async function getDomainFromURL(context: any): Promise<Domain> {
   const subdomain = header['x-things-factory-domain'] || getSubdomainFromURL(context)
 
   if (subdomain) {
-    return await getRepository(Domain).findOne({ subdomain }, { cache: true })
+    return await getRepository(Domain).findOne({ where: { subdomain }, cache: true })
   }
 }
 

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

@@ -1,4 +1,5 @@
 import { Brackets, EntityMetadata, Repository, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm'
+import { RelationMetadata } from 'typeorm/metadata/RelationMetadata'
 
 import { Filter, ListParam } from '../service/common-types/list-param'
 import { Domain } from '../service/domain/domain'
@@ -105,7 +106,7 @@ function addCondition<T>(
 ): void {
   const { name, operator, value } = filter
   const values = value instanceof Array ? value : [value]
-  const entityAlias = selectQueryBuilder.alias
+  var entityAlias = selectQueryBuilder.alias
 
   var { relationColumn, columnName } = filtersMap[name] || {}
   /*
@@ -117,14 +118,36 @@ function addCondition<T>(
     - 이 경우는 columnName 만 적용한다.
   */
   if (relationColumn) {
-    var relationColumnMeta = metadata.columns.find(column => column.propertyName === relationColumn)
-    if (!relationColumnMeta) {
-      console.warn(`relationColumn "${relationColumn}" in filtersMap for "${name}" is not a relation column`)
-      return
+    const columns = relationColumn.split('.')
+    var entityMetadata: EntityMetadata
+    var relation: RelationMetadata
+
+    for (const rcolumn of columns) {
+      if (relation) {
+        const { propertyName } = relationColumnMeta
+        const property = `${entityAlias}.${propertyName}`
+
+        entityAlias = `${entityMetadata.tableName}-${entityMetadata.tableName}` as string
+
+        if (andCondition) {
+          selectQueryBuilder.innerJoin(property, entityAlias)
+        } else {
+          selectQueryBuilder.leftJoin(property, entityAlias)
+        }
+      } else {
+        entityMetadata = metadata
+      }
+
+      var relationColumnMeta = entityMetadata.columns.find(column => column.propertyName === rcolumn)
+      if (!relationColumnMeta) {
+        console.warn(`relationColumn "${relationColumn}" in filtersMap for "${name}" is not a relation column`)
+        return
+      }
+
+      relation = relationColumnMeta.relationMetadata
+      entityMetadata = relation.inverseEntityMetadata
     }
 
-    var relation = relationColumnMeta.relationMetadata
-    var entityMetadata = relation.inverseEntityMetadata
     var columnMeta = entityMetadata.columns.find(column => column.propertyName === (columnName || 'name'))
     if (!columnMeta) {
       console.warn(`columnName "${columnName}" in filtersMap for "${name}" is not a column`)

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

@@ -29,7 +29,7 @@ const OPERATION_FUNCTION_MAP: { [operator: string]: (value: any) => FindOperator
   between: value => Between(value[0], value[1])
 }
 
-function getOperatorFunction({ operator, value }: { operator: string; value: any }): FindOperator<any> {
+function getOperatorFunction({ operator, value }: Filter): FindOperator<any> {
   return OPERATION_FUNCTION_MAP[operator](value)
 }