@things-factory/setting-base 5.0.7 → 6.0.0-alpha.0

package/server/service/partner-setting/partner-setting-query.ts

@@ -1,7 +1,9 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
-import { Domain, Filter, Pagination, Sorting, buildQuery, ObjectRef } from '@things-factory/shell'
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, Filter, getRepository, ObjectRef, Pagination, Sorting } from '@things-factory/shell'
+
 import { Setting } from '../setting/setting'
 import { PartnerSetting } from './partner-setting'
 import { PartnerSettingList } from './partner-setting-type'
@@ -12,13 +14,13 @@ export class PartnerSettingQuery {
   async partnerSetting(
     @Arg('name') name: string,
     @Arg('partnerDomainId') partnerDomainId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<PartnerSetting> {
-    const { domain }: { domain: Domain } = context.state
-    const setting: Setting = await getRepository(Setting).findOne({ where: { domain, name } })
+    const { domain } = context.state
+    const setting: Setting = await getRepository(Setting).findOne({ where: { domain: { id: domain.id }, name } })
 
     const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
-      where: { domain, setting, partnerDomain: partnerDomainId }
+      where: { domain: { id: domain.id }, setting: { id: setting.id }, partnerDomain: { id: partnerDomainId } }
     })
 
     if (!partnerSetting) throw new Error(`${name} setting is not found`)
@@ -32,7 +34,7 @@ export class PartnerSettingQuery {
     @Arg('pagination', type => Pagination) pagination: Pagination,
     @Arg('sortings', type => [Sorting]) sortings: Sorting[],
     @Arg('partnerDomain', type => ObjectRef) partnerDomain: ObjectRef,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<PartnerSettingList> {
     const qb: SelectQueryBuilder<PartnerSetting> = getRepository(PartnerSetting).createQueryBuilder()
     buildQuery(qb, { filters, pagination, sortings }, context)
@@ -45,12 +47,12 @@ export class PartnerSettingQuery {
 
   @FieldResolver(type => Domain)
   async partnerDomain(@Root() partnerSetting: PartnerSetting): Promise<Domain> {
-    return await getRepository(Domain).findOne(partnerSetting.partnerDomainId)
+    return await getRepository(Domain).findOneBy({ id: partnerSetting.partnerDomainId })
   }
 
   @FieldResolver(type => Setting)
   async setting(@Root() partnerSetting: PartnerSetting): Promise<Setting> {
-    return await getRepository(Setting).findOne(partnerSetting.settingId)
+    return await getRepository(Setting).findOneBy({ id: partnerSetting.settingId })
   }
 
   @FieldResolver(type => String)
@@ -59,7 +61,7 @@ export class PartnerSettingQuery {
       return partnerSetting.setting.name
     }
 
-    return (await getRepository(Setting).findOne(partnerSetting.settingId))?.name
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.name
   }
 
   async description(@Root() partnerSetting: PartnerSetting): Promise<string> {
@@ -67,7 +69,7 @@ export class PartnerSettingQuery {
       return partnerSetting.setting.description
     }
 
-    return (await getRepository(Setting).findOne(partnerSetting.settingId))?.description
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.description
   }
 
   async category(@Root() partnerSetting: PartnerSetting): Promise<string> {
@@ -75,21 +77,21 @@ export class PartnerSettingQuery {
       return partnerSetting.setting.category
     }
 
-    return (await getRepository(Setting).findOne(partnerSetting.settingId))?.category
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.category
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() partnerSetting: PartnerSetting): Promise<Domain> {
-    return await getRepository(Domain).findOne(partnerSetting.domainId)
+    return await getRepository(Domain).findOneBy({ id: partnerSetting.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() partnerSetting: PartnerSetting): Promise<User> {
-    return await getRepository(User).findOne(partnerSetting.updaterId)
+    return await getRepository(User).findOneBy({ id: partnerSetting.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() partnerSetting: PartnerSetting): Promise<User> {
-    return await getRepository(User).findOne(partnerSetting.creatorId)
+    return await getRepository(User).findOneBy({ id: partnerSetting.creatorId })
   }
 }

package/server/service/partner-setting/partner-setting.ts

@@ -1,20 +1,21 @@
+import { Field, ID, ObjectType } from 'type-graphql'
 import {
-  EntityManager,
-  Repository,
-  getRepository,
+  Column,
   CreateDateColumn,
-  UpdateDateColumn,
   Entity,
+  EntityManager,
+  getRepository,
   Index,
-  Column,
-  RelationId,
   ManyToOne,
-  PrimaryGeneratedColumn
+  PrimaryGeneratedColumn,
+  RelationId,
+  Repository,
+  UpdateDateColumn
 } from 'typeorm'
-import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
 
-import { Domain } from '@things-factory/shell'
 import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
 import { Setting } from '../setting/setting'
 
 @Entity()
@@ -97,14 +98,14 @@ export class PartnerSetting {
     const partnerSettingRepo: Repository<PartnerSetting> =
       tx?.getRepository(PartnerSetting) || getRepository(PartnerSetting)
     const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
-    const setting: Setting = await settingRepo.findOne({ domain, name })
+    const setting: Setting = await settingRepo.findOneBy({ domain: { id: domain.id }, name })
 
     if (!setting) throw new Error(`No setting found has '${name}' as its name`)
 
-    const domainSetting: PartnerSetting = await partnerSettingRepo.findOne({
-      domain,
-      partnerDomain: partnerDomain,
-      setting
+    const domainSetting: PartnerSetting = await partnerSettingRepo.findOneBy({
+      domain: { id: domain.id },
+      partnerDomain: { id: partnerDomain.id },
+      setting: { id: setting.id }
     })
 
     return domainSetting?.value || setting?.value

package/server/service/setting/setting-mutation.ts

@@ -1,7 +1,6 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { EntityManager, getRepository, In } from 'typeorm'
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
 import { Setting } from './setting'
 import { NewSetting, SettingPatch } from './setting-type'
 
@@ -10,8 +9,8 @@ export class SettingMutation {
   @Directive('@transaction')
   @Directive('@privilege(category: "setting", privilege: "mutation")')
   @Mutation(returns => Setting, { description: 'To create new Setting' })
-  async createSetting(@Arg('setting') setting: NewSetting, @Ctx() context: any): Promise<Setting> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+  async createSetting(@Arg('setting') setting: NewSetting, @Ctx() context: ResolverContext): Promise<Setting> {
+    const { tx, domain, user } = context.state
     return await tx.getRepository(Setting).save({
       domain,
       ...setting,
@@ -26,12 +25,12 @@ export class SettingMutation {
   async updateSetting(
     @Arg('name') name: string,
     @Arg('patch') patch: SettingPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Setting> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const repository = tx.getRepository(Setting)
-    const setting = await repository.findOne({ domain, name })
+    const setting = await repository.findOneBy({ domain: { id: domain.id }, name })
 
     return await repository.save({
       creater: user,
@@ -47,9 +46,9 @@ export class SettingMutation {
   @Mutation(returns => [Setting], { description: "To modify multiple Settings' information" })
   async updateMultipleSetting(
     @Arg('patches', type => [SettingPatch]) patches: SettingPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Setting[]> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
@@ -61,7 +60,7 @@ export class SettingMutation {
         const newRecord = _createRecords[i]
 
         const result = await settingRepo.save({
-          domain,
+          domain: { id: domain.id },
           creator: user,
           updater: user,
           ...newRecord
@@ -74,7 +73,7 @@ export class SettingMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const setting = await settingRepo.findOne({ id: newRecord.id })
+        const setting = await settingRepo.findOneBy({ id: newRecord.id })
 
         const result = await settingRepo.save({
           ...setting,
@@ -92,8 +91,8 @@ export class SettingMutation {
   @Directive('@transaction')
   @Directive('@privilege(category: "setting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete Setting' })
-  async deleteSetting(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteSetting(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(Setting).delete({ domain, name })
     return true
@@ -102,11 +101,14 @@ export class SettingMutation {
   @Directive('@transaction')
   @Directive('@privilege(category: "setting", privilege: "mutation")')
   @Mutation(returns => Boolean, { description: 'To delete multiple settings' })
-  async deleteSettings(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteSettings(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(Setting).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
 

package/server/service/setting/setting-query.ts

@@ -1,11 +1,11 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
-import { Domain, ListParam, buildQuery } from '@things-factory/shell'
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
 import { User } from '@things-factory/auth-base'
+import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
+
+import { PartnerSetting } from '../partner-setting/partner-setting'
 import { Setting } from './setting'
 import { SettingList } from './setting-type'
-import { Partner } from '@things-factory/auth-base'
-import { PartnerSetting } from '../partner-setting/partner-setting'
 
 @Resolver(Setting)
 export class SettingQuery {
@@ -14,19 +14,19 @@ export class SettingQuery {
   async setting(
     @Arg('name') name: string,
     @Arg('partnerDomainId', { nullable: true }) partnerDomainId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Setting> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
 
-    let setting: Setting = await getRepository(Setting).findOne({ where: { domain, name } })
+    let setting: Setting = await getRepository(Setting).findOne({ where: { domain: { id: domain.id }, name } })
     if (!setting) throw new Error(`${name} setting not found`)
 
     if (partnerDomainId) {
-      const partnerDomain: Domain = await getRepository(Domain).findOne(partnerDomainId)
-      const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
-        setting,
-        domain,
-        partnerDomain
+      const partnerDomain: Domain = await getRepository(Domain).findOneBy({ id: partnerDomainId })
+      const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOneBy({
+        setting: { id: setting.id },
+        domain: { id: domain.id },
+        partnerDomain: { id: partnerDomain.id }
       })
       if (partnerSetting) setting.value = partnerSetting.value
     }
@@ -36,7 +36,7 @@ export class SettingQuery {
 
   @Directive('@privilege(category: "setting", privilege: "query")')
   @Query(returns => SettingList, { description: 'To fetch multiple Settings' })
-  async settings(@Args() params: ListParam, @Ctx() context: any): Promise<SettingList> {
+  async settings(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<SettingList> {
     const queryBuilder = getRepository(Setting).createQueryBuilder()
     buildQuery(queryBuilder, params, context)
 
@@ -44,40 +44,40 @@ export class SettingQuery {
     return { items, total }
   }
 
-  @FieldResolver(type => Domain)
-  async value(@Root() setting: Setting, @Ctx() context: any) {
-    const { user, domain } = context.state
-    const userDomains: Domain[] = user.domains
-    let value: string = setting.value
+  // @FieldResolver(type => Domain)
+  // async value(@Root() setting: Setting, @Ctx() context: ResolverContext) {
+  //   const { user, domain } = context.state
+  //   const userDomains: Domain[] = user.domains
+  //   let value: string = setting.value
 
-    const partner: Partner = await getRepository(Partner).findOne({
-      where: { domain, partnerDomain: In(userDomains.map((userDomain: Domain) => userDomain.id)) },
-      relations: ['partnerDomain']
-    })
-    if (partner?.partnerDomain) {
-      const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
-        setting,
-        domain,
-        partnerDomain: partner.partnerDomain
-      })
-      if (partnerSetting) value = partnerSetting.value
-    }
+  //   const partner: Partner = await getRepository(Partner).findOne({
+  //     where: { domain: { id: domain.id }, partnerDomain: In(userDomains.map((userDomain: Domain) => userDomain.id)) },
+  //     relations: ['partnerDomain']
+  //   })
+  //   if (partner?.partnerDomain) {
+  //     const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
+  //       setting,
+  //       domain,
+  //       partnerDomain: partner.partnerDomain
+  //     })
+  //     if (partnerSetting) value = partnerSetting.value
+  //   }
 
-    return value
-  }
+  //   return value
+  // }
 
   @FieldResolver(type => Domain)
   async domain(@Root() setting: Setting) {
-    return await getRepository(Domain).findOne(setting.domainId)
+    return await getRepository(Domain).findOneBy({ id: setting.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() setting: Setting): Promise<User> {
-    return await getRepository(User).findOne(setting.updaterId)
+    return await getRepository(User).findOneBy({ id: setting.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() setting: Setting): Promise<User> {
-    return await getRepository(User).findOne(setting.creatorId)
+    return await getRepository(User).findOneBy({ id: setting.creatorId })
   }
 }