@things-factory/shell 6.0.0-zeta.8 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/shell",
-  "version": "6.0.0-zeta.8",
+  "version": "6.0.0",
   "description": "Core module for framework",
   "bin": {
     "things-factory": "bin/things-factory",
@@ -30,13 +30,12 @@
     "test": "NODE_ENV=test jest"
   },
   "dependencies": {
-    "@anchan828/typeorm-history": "^1.0.16",
     "@apollo/client": "^3.6.9",
     "@graphql-tools/merge": "^8.3.0",
     "@graphql-tools/schema": "^8.5.0",
     "@graphql-tools/utils": "^8.8.0",
     "@hatiolab/koa-webpack": "^6.0.0",
-    "@hatiolab/things-scene": "^3.0.23",
+    "@hatiolab/things-scene": "^3.2.0",
     "@koa/cors": "^3.3.0",
     "@material/mwc-button": "^0.27.0",
     "@material/mwc-fab": "^0.27.0",
@@ -50,11 +49,12 @@
     "@operato/help": "^1.0.1",
     "@operato/layout": "^1.0.1",
     "@operato/shell": "^1.0.1",
+    "@operato/typeorm-history": "^1.1.65",
     "@operato/utils": "^1.0.1",
     "@things-factory/ejs-remote": "^6.0.0-zeta.1",
-    "@things-factory/env": "^6.0.0-zeta.1",
-    "@things-factory/styles": "^6.0.0-zeta.1",
-    "@things-factory/utils": "^6.0.0-zeta.1",
+    "@things-factory/env": "^6.0.0-zeta.30",
+    "@things-factory/styles": "^6.0.0-zeta.27",
+    "@things-factory/utils": "^6.0.0",
     "@webcomponents/webcomponentsjs": "^2.6.0",
     "@webpack-contrib/schema-utils": "^1.0.0-beta.0",
     "apollo-server-core": "^3.10.0",
@@ -96,7 +96,7 @@
     "koa-send": "^5.0.0",
     "koa-static": "^5.0.0",
     "koa2-connect-history-api-fallback": "^0.1.2",
-    "lit": "^2.4.0",
+    "lit": "^2.5.0",
     "loader-utils": "^2.0.0",
     "lodash": "^4.17.21",
     "lodash-es": "^4.17.21",
@@ -131,5 +131,5 @@
     "pg": "^8.7.3",
     "sqlite3": "^5.0.8"
   },
-  "gitHead": "84c5baee000c881c95673adf97eb30992e09e553"
+  "gitHead": "8797165c1e1f734a52cfd2c1ebbb53fe126796e9"
 }

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

@@ -26,6 +26,7 @@ export const transactionDirectiveResolver = (schema: GraphQLSchema) =>
               ...context.state,
               tx
             }
+            wrap.t = context.t
 
             let result = await resolve.call(this, source, args, wrap, info)
 

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}).`)
       }