@things-factory/shell 6.0.0-zeta.30 → 6.0.0-zeta.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "6.0.0-zeta.30",
+  "version": "6.0.0-zeta.43",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -131,5 +131,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "4c28510000cab653ca9358c0cda4a2f189afffe1"
+  "gitHead": "f43b9c1e5447ff2d5739a057c7154e1e1adc31b0"
 }

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

@@ -4,14 +4,15 @@ import { In, Repository } from 'typeorm'
 import { slugger } from '@things-factory/utils'
 
 import { getRepository } from '../../initializers/database'
-import { buildQuery } from '../../utils/list-query-builder'
+import { getQueryBuilderFromListParams } from '../../utils/get-query-builder-from-list-params'
+
 import { ListParam } from '../common-types/list-param'
 import { Domain } from './domain'
 import { DomainList, DomainPatch } from './domain-types'
 
 @Resolver(Domain)
 export class DomainResolver {
-  @Directive('@privilege(category: "system", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
+  @Directive('@privilege(category: "system", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
   @Query(returns => Domain, { description: 'To fetch domain' })
   async domain(@Arg('id') id: string): Promise<Domain> {
     const repository = getRepository(Domain)
@@ -19,35 +20,37 @@ export class DomainResolver {
     return await repository.findOneBy({ id })
   }
 
-  @Directive('@privilege(category: "system", privilege: "query", superUserGranted: true)')
-  @Query(returns => DomainList, { description: 'To fetch multiple domain' })
+  @Directive('@privilege(superUserGranted: true)')
+  @Query(returns => DomainList, { description: 'To fetch all domains (Only superuser is granted this privilege.)' })
   async domains(@Args() params: ListParam, @Ctx() context: any): Promise<DomainList> {
-    const queryBuilder = getRepository(Domain).createQueryBuilder()
-
-    buildQuery(queryBuilder, params || {}, context, {
-      domainRef: false,
+    const queryBuilder = await getQueryBuilderFromListParams({
+      repository: getRepository(Domain),
+      alias: 'ContactPoint',
+      params,
       searchables: ['name', 'description', 'subdomain']
     })
+
     const [items, total] = await queryBuilder.getManyAndCount()
 
     return { items, total }
   }
 
-  @Query(returns => Boolean, { description: 'To check if given domain is exist' })
-  async checkExistsDomain(@Arg('name') name: string) {
-    const domainRepository: Repository<Domain> = getRepository(Domain)
-    const targetSubdomain: string = slugger(name)
+  // @Query(returns => Boolean, { description: 'To check if given domain is exist' })
+  // async checkExistsDomain(@Arg('name') name: string) {
+  //   const domainRepository: Repository<Domain> = getRepository(Domain)
+  //   const targetSubdomain: string = slugger(name)
 
-    const oldDomain = await domainRepository.findOneBy({ subdomain: targetSubdomain })
-    if (oldDomain) {
-      throw new Error('domain is duplicated')
-    }
+  //   const oldDomain = await domainRepository.findOneBy({ subdomain: targetSubdomain })
+  //   if (oldDomain) {
+  //     throw new Error('domain is duplicated')
+  //   }
 
-    return true
-  }
+  //   return true
+  // }
 
-  @Directive('@privilege(category: "system", privilege: "mutation", superUserGranted: true)')
-  @Mutation(returns => Domain, { description: 'To create domain' })
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, { description: 'To create domain (Only superuser is granted this privilege.)' })
   async createDomain(@Arg('domainInput') domainInput: DomainPatch) {
     const { name, description } = domainInput
     const domainRepo: Repository<Domain> = getRepository(Domain)
@@ -61,14 +64,18 @@ export class DomainResolver {
     return await domainRepo.save({ name, description, subdomain })
   }
 
-  @Directive('@privilege(category: "system", privilege: "mutation", superUserGranted: true)')
-  @Mutation(returns => Domain, { description: 'To delete domain' })
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, { description: 'To delete domain (Only superuser is granted this privilege.)' })
   async deleteDomain(@Arg('name') name: string) {
     return await getRepository(Domain).delete({ name })
   }
 
-  @Directive('@privilege(category: "system", privilege: "mutation", superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To delete multiple domains' })
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, {
+    description: 'To delete multiple domains (Only superuser is granted this privilege.)'
+  })
   async deleteDomains(@Arg('names', () => [String]) names: string[]) {
     const domains: Domain[] = await getRepository(Domain).find({ where: { name: In(names) } })
     const domainIds: string[] = domains.map(domain => domain.id)
@@ -76,8 +83,11 @@ export class DomainResolver {
     await getRepository(Domain).delete({ id: In(domainIds) })
   }
 
-  @Directive('@privilege(category: "system", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Domain, { description: 'To update domain' })
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Domain, {
+    description: 'To update domain (Only superuser is granted this privilege.)'
+  })
   async updateDomain(@Arg('name') name: string, @Arg('patch', () => DomainPatch) patch: DomainPatch) {
     const repository = getRepository(Domain)
     const domain: Domain = await repository.findOneBy({ name })
@@ -88,8 +98,11 @@ export class DomainResolver {
     } as any)
   }
 
-  @Directive('@privilege(category: "system", privilege: "mutation", superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'To update multiple domains' })
+  @Directive('@transaction')
+  @Directive('@privilege(superUserGranted: true)')
+  @Mutation(returns => Boolean, {
+    description: 'To update multiple domains (Only superuser is granted this privilege.)'
+  })
   async updateDomains(@Arg('patches', () => [DomainPatch]) patches: DomainPatch[]): Promise<boolean> {
     const domainRepo: Repository<Domain> = getRepository(Domain)
 

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

@@ -1,5 +1,6 @@
 import { ObjectType, InputType, Field, Int } from 'type-graphql'
 import { Domain } from './domain'
+import { ObjectRef } from '../common-types/object-ref'
 
 @InputType()
 export class DomainInput {

package/server/service/domain/domain.ts

@@ -2,9 +2,9 @@ import { Column, CreateDateColumn, Entity, Index, UpdateDateColumn } from 'typeo
 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 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
 
@@ -14,33 +14,34 @@ const domainPrimaryStrategy = domainPrimaryOption?.strategy
 export class Domain {
   @Field(type => ID)
   @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
-          }
+    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'
         }
-      },
-      generated:generatedStrategy.indexOf(domainPrimaryStrategy)>=0?domainPrimaryStrategy:false
-    }:{
-      type: 'uuid',
-      primary:true,
-      generated:'uuid'
-    }
   )
   readonly id: string
 

package/server/service/subscription-data/data-resolver.ts

@@ -16,7 +16,8 @@ export class DataResolver {
         throw new Error('domain and tag required')
       }
 
-      if (!user.domains?.find(d => d.subdomain === subdomain)) {
+      //@ts-ignore
+      if (!user.domains?.find(d => d.subdomain === subdomain) && !process.superUserGranted(domain, user)) {
         throw new Error(`domain(${subdomain}) is not working for user(${user.email}).`)
       }