@things-factory/sales-base 5.0.13 → 6.0.0-alpha.1

package/server/service/arrival-notice/arrival-notice-query.ts

@@ -1,11 +1,11 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { EntityManager, getRepository, In, SelectQueryBuilder } from 'typeorm'
+import { EntityManager, In, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 import { checkUserBelongsDomain, User } from '@things-factory/auth-base'
 import { Bizplace, getCompanyBizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { ProductDetail } from '@things-factory/product-base'
-import { buildQuery, Domain, ListParam } from '@things-factory/shell'
+import { buildQuery, Domain, getRepository, ListParam } from '@things-factory/shell'
 
 import { ArrivalNoticeList, NewArrivalNotice, RawArrivalNotice } from '../'
 import { ATTACHMENT_TYPE, ORDER_STATUS } from '../../constants'
@@ -17,11 +17,11 @@ export class ArrivalNoticeQuery {
   @Directive('@privilege(category: "order", privilege: "query")')
   @Query(returns => ArrivalNotice)
   async arrivalNotice(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('name', { nullable: true }) name?: string,
     @Arg('refNo', { nullable: true }) refNo?: string
   ): Promise<ArrivalNotice> {
-    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace: Bizplace } = context.state
+    const { domain, user, bizplace }: { domain: Domain; user: User; bizplace?: Bizplace } = context.state
 
     let param: any = { domain, bizplace: bizplace ? bizplace : In(await getPermittedBizplaceIds(domain, user)) }
 
@@ -58,7 +58,7 @@ export class ArrivalNoticeQuery {
     if (foundGAN) {
       const foundAttachments: Attachment[] = await getRepository(Attachment).find({
         where: {
-          domain,
+          domain: { id: domain.id },
           refBy: foundGAN?.id,
           category: ATTACHMENT_TYPE.GAN
         }
@@ -67,7 +67,7 @@ export class ArrivalNoticeQuery {
       const foundPOAttachments: Attachment[] = foundGAN?.purchaseOrder?.id
         ? await getRepository(Attachment).find({
             where: {
-              domain,
+              domain: { id: domain.id },
               refBy: foundGAN.purchaseOrder?.id,
               category: ATTACHMENT_TYPE.PO
             }
@@ -115,8 +115,8 @@ export class ArrivalNoticeQuery {
 
   @Directive('@privilege(category: "order_customer", privilege: "query")')
   @Query(returns => ArrivalNoticeList)
-  async arrivalNotices(@Ctx() context: any, @Args() params: ListParam): Promise<ArrivalNoticeList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async arrivalNotices(@Ctx() context: ResolverContext, @Args() params: ListParam): Promise<ArrivalNoticeList> {
+    const { domain, user } = context.state
 
     if (await checkUserBelongsDomain(domain, user)) {
       if (!params.filters.some(e => e.name === 'status') && !params.filters.some(e => e.name === 'name')) {
@@ -188,7 +188,7 @@ export class ArrivalNoticeQuery {
     )
 
     const arrChildSortData = ['bizplace']
-    const sort = (params.sortings || []).reduce(
+    const sort: OrderByCondition = (params.sortings || []).reduce(
       (acc, sort) => ({
         ...acc,
         [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + sort.name]: sort.desc ? 'DESC' : 'ASC'
@@ -205,9 +205,9 @@ export class ArrivalNoticeQuery {
 
   @Directive('@privilege(category: "order_warehouse", privilege: "query")')
   @Query(returns => ArrivalNoticeList)
-  async arrivalNoticeRequests(@Args() params: ListParam, @Ctx() context: any): Promise<ArrivalNoticeList> {
+  async arrivalNoticeRequests(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<ArrivalNoticeList> {
     try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      const { domain, user } = context.state
       const statusFilter = params.filters.some(e => e.name === 'status')
       const bizplaceFilter = params.filters.find(param => param.name === 'bizplaceId')
 
@@ -279,7 +279,7 @@ export class ArrivalNoticeQuery {
       )
 
       const arrChildSortData = ['bizplace']
-      const sort = (params.sortings || []).reduce(
+      const sort: OrderByCondition = (params.sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
           [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'an.' + sort.name]: sort.desc
@@ -302,7 +302,7 @@ export class ArrivalNoticeQuery {
   @Directive('@transaction')
   @Query(returns => [RawArrivalNotice])
   async validateBulkArrivalNotices(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('rawArrivalNotices', type => [NewArrivalNotice], { nullable: true }) rawArrivalNotices: NewArrivalNotice[],
     @Arg('bizplaceId', type => String) bizplaceId: string
   ): Promise<RawArrivalNotice[]> {
@@ -312,17 +312,17 @@ export class ArrivalNoticeQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() arrivalNotice: ArrivalNotice): Promise<Domain> {
-    return await getRepository(Domain).findOne(arrivalNotice.domainId)
+    return await getRepository(Domain).findOneBy({ id: arrivalNotice.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
-    return await getRepository(User).findOne(arrivalNotice.creatorId)
+    return await getRepository(User).findOneBy({ id: arrivalNotice.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() arrivalNotice: ArrivalNotice): Promise<User> {
-    return await getRepository(User).findOne(arrivalNotice.updaterId)
+    return await getRepository(User).findOneBy({ id: arrivalNotice.updaterId })
   }
 }
 
@@ -478,7 +478,6 @@ export async function validateBulkArrivalNoticesFunction(
 	        AND raw.import_cargo = an.import_cargo 
 	        LEFT JOIN products pr ON LOWER(pr.sku) = LOWER(raw.sku)
 	        LEFT JOIN product_details pd ON pr.id = pd.product_id
-	        AND pr.bizplace_id = $1
 	        AND CASE WHEN raw.packing_type NOTNULL AND raw.packing_size NOTNULL AND raw.uom NOTNULL
 	          THEN pd.packing_type = raw.packing_type AND pd.packing_size = raw.packing_size AND pd.uom = raw.uom 
 	          WHEN raw.packing_type NOTNULL AND raw.packing_size NOTNULL AND raw.uom ISNULL
@@ -486,6 +485,7 @@ export async function validateBulkArrivalNoticesFunction(
 	            WHEN raw.packing_type ISNULL AND raw.packing_size ISNULL AND raw.uom NOTNULL
 	              THEN pd.uom = raw.uom AND pd.is_default IS TRUE ELSE pd.is_default IS TRUE
 	        END
+        WHERE pr.bizplace_id = $1
 	      GROUP BY raw.ref_no, raw.ref_no_2, raw.ref_no_3, raw.eta_date, raw.truck_no, raw.own_transport, raw.container, raw.container_no, raw.container_size, raw.import_cargo, raw.loose_item,
 	        pr.id, pd.id, raw.sku, pr.name, pr.description, raw.batch_id, raw.batch_id_ref, raw.packing_type, raw.packing_size, raw.uom, raw.unit_price, raw.manufacture_date, an.ref_no, an.name
       ) SELECT foo.*, 

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

@@ -1,7 +1,10 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, MoreThan } from 'typeorm'
+
 import { Bizplace } from '@things-factory/biz-base'
+import { getRepository } from '@things-factory/shell'
 import { TransportDriver, TransportVehicle } from '@things-factory/transport-base'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, MoreThan } from 'typeorm'
+
 import {
   ClaimDetail,
   ClaimDetailPatch,
@@ -19,8 +22,8 @@ export class ClaimMutation {
   @Directive('@privilege(category: "claim", privilege: "mutation" )')
   @Directive('@transaction')
   @Mutation(returns => Claim)
-  async createClaim(@Arg('claim', type => NewClaim) claim: NewClaim, @Ctx() context: any): Promise<Claim> {
-    const { tx }: { tx: EntityManager } = context.state
+  async createClaim(@Arg('claim', type => NewClaim) claim: NewClaim, @Ctx() context: ResolverContext): Promise<Claim> {
+    const { tx } = context.state
 
     let arrClaimOrdersName = claim.claimOrders.map(item => {
       return item.name
@@ -82,7 +85,7 @@ export class ClaimMutation {
     let month = today.getMonth()
     let date = today.getDate()
 
-    const [items, total] = await getRepository(Claim).findAndCount({
+    const [items, total] = await getRepository(Claim).findAndCountBy({
       createdAt: MoreThan(new Date(year, month, date))
     })
 
@@ -143,12 +146,12 @@ export class ClaimMutation {
   async updateClaim(
     @Arg('id') id: string,
     @Arg('patch', type => ClaimPatch) patch: ClaimPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Claim> {
     try {
-      const { tx }: { tx: EntityManager } = context.state
+      const { tx } = context.state
       const targetClaim: Claim = await tx.getRepository(Claim).findOne({
-        where: { domain: context.state.domain, id },
+        where: { domain: { id: context.state.domain.id }, id },
         relations: ['claimDetails', 'claimOrders', 'bizplace', 'updater']
       })
       if (!targetClaim) throw new Error('claim not exists')
@@ -244,7 +247,7 @@ export class ClaimMutation {
   @Mutation(returns => [Claim])
   async updateMultipleClaim(
     @Arg('patches', type => [ClaimPatch]) patches: ClaimPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Claim[]> {
     let results: Claim[] = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -269,7 +272,7 @@ export class ClaimMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const claim = await claimRepo.findOne(newRecord.id)
+        const claim = await claimRepo.findOneBy({ id: newRecord.id })
 
         const result = await claimRepo.save({
           ...claim,
@@ -285,15 +288,18 @@ export class ClaimMutation {
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaim(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    await getRepository(Claim).delete({ domain: context.state.domain, name })
+  async deleteClaim(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    await getRepository(Claim).delete({ domain: { id: context.state.domain.id }, name })
     return true
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaims(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteClaims(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     await getRepository(Claim).delete({
-      domain: context.state.domain,
+      domain: { id: context.state.domain.id },
       name: In(names)
     })
 

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

@@ -1,14 +1,15 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { ClaimList } from '../'
 import { Claim } from './claim'
 
 @Resolver(Claim)
 export class ClaimQuery {
   @Query(returns => Claim)
-  async claim(@Arg('id') id: string, @Ctx() context: any): Promise<Claim> {
+  async claim(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Claim> {
     return await getRepository(Claim).findOne({
       where: {
         domain: context.state.domain,
@@ -44,7 +45,7 @@ export class ClaimQuery {
 
   @Query(returns => [Claim])
   async claimOrderList(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('transportDriver', { nullable: true }) transportDriver?: string,
     @Arg('transportVehicle', { nullable: true }) transportVehicle?: string
   ): Promise<Claim[]> {
@@ -72,7 +73,7 @@ export class ClaimQuery {
 
   @Query(returns => Claim)
   async claimOrderDetail(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[]
   ): Promise<Claim> {
     let claim = new Claim()
@@ -106,16 +107,16 @@ export class ClaimQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() claim: Claim): Promise<Domain> {
-    return await getRepository(Domain).findOne(claim.domainId)
+    return await getRepository(Domain).findOneBy({ id: claim.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() claim: Claim): Promise<User> {
-    return await getRepository(User).findOne(claim.creatorId)
+    return await getRepository(User).findOneBy({ id: claim.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() claim: Claim): Promise<User> {
-    return await getRepository(User).findOne(claim.updaterId)
+    return await getRepository(User).findOneBy({ id: claim.updaterId })
   }
 }

package/server/service/claim-detail/claim-detail-mutation.ts

@@ -1,5 +1,8 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { ClaimDetailPatch, NewClaimDetail } from '../'
 import { ClaimDetail } from './claim-detail'
 
@@ -8,7 +11,7 @@ export class ClaimDetailMutation {
   @Mutation(returns => ClaimDetail)
   async createClaimDetail(
     @Arg('claimDetail', type => NewClaimDetail) claimDetail: NewClaimDetail,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimDetail> {
     return await getRepository(ClaimDetail).save({
       ...claimDetail,
@@ -22,11 +25,11 @@ export class ClaimDetailMutation {
   async updateClaimDetail(
     @Arg('name') name: string,
     @Arg('patch', type => ClaimDetailPatch) patch: ClaimDetailPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimDetail> {
     const repository = getRepository(ClaimDetail)
     const claimDetail = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     return await repository.save({
@@ -39,7 +42,7 @@ export class ClaimDetailMutation {
   @Mutation(returns => [ClaimDetail])
   async updateMultipleClaimDetail(
     @Arg('patches', type => [ClaimDetailPatch]) patches: ClaimDetailPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimDetail[]> {
     let results: ClaimDetail[] = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -64,7 +67,7 @@ export class ClaimDetailMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const claimDetail = await claimDetailRepo.findOne(newRecord.id)
+        const claimDetail = await claimDetailRepo.findOneBy({ id: newRecord.id })
 
         const result = await claimDetailRepo.save({
           ...claimDetail,
@@ -80,15 +83,18 @@ export class ClaimDetailMutation {
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaimDetail(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    await getRepository(ClaimDetail).delete({ domain: context.state.domain, name })
+  async deleteClaimDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    await getRepository(ClaimDetail).delete({ domain: { id: context.state.domain.id }, name })
     return true
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaimDetails(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteClaimDetails(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     await getRepository(ClaimDetail).delete({
-      domain: context.state.domain,
+      domain: { id: context.state.domain.id },
       name: In(names)
     })
     return true

package/server/service/claim-detail/claim-detail-query.ts

@@ -1,16 +1,21 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { ClaimDetailList } from '../'
 import { ClaimDetail } from './claim-detail'
 
 @Resolver(ClaimDetail)
 export class ClaimDetailQuery {
   @Query(returns => ClaimDetail)
-  async claimDetail(@Ctx() context: any, @Arg('name', { nullable: true }) name?: string): Promise<ClaimDetail> {
+  async claimDetail(
+    @Ctx() context: ResolverContext,
+    @Arg('name', { nullable: true }) name?: string
+  ): Promise<ClaimDetail> {
     return await getRepository(ClaimDetail).findOne({
-      where: { domain: context.state.domain, name, relations: ['domain', 'creator', 'updater'] }
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
     })
   }
 
@@ -35,16 +40,16 @@ export class ClaimDetailQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() claimDetail: ClaimDetail): Promise<Domain> {
-    return await getRepository(Domain).findOne(claimDetail.domainId)
+    return await getRepository(Domain).findOneBy({ id: claimDetail.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() claimDetail: ClaimDetail): Promise<User> {
-    return await getRepository(User).findOne(claimDetail.creatorId)
+    return await getRepository(User).findOneBy({ id: claimDetail.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() claimDetail: ClaimDetail): Promise<User> {
-    return await getRepository(User).findOne(claimDetail.updaterId)
+    return await getRepository(User).findOneBy({ id: claimDetail.updaterId })
   }
 }

package/server/service/claim-order/claim-order-mutation.ts

@@ -1,5 +1,8 @@
 import { Arg, Ctx, Mutation, Resolver } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { ClaimOrderPatch, NewClaimOrder } from '../'
 import { ClaimOrder } from './claim-order'
 
@@ -8,7 +11,7 @@ export class ClaimOrderMutation {
   @Mutation(returns => ClaimOrder)
   async createClaimOrder(
     @Arg('claimOrder', type => NewClaimOrder) claimOrder: NewClaimOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimOrder> {
     return await getRepository(ClaimOrder).save({
       ...claimOrder,
@@ -22,11 +25,11 @@ export class ClaimOrderMutation {
   async updateClaimOrder(
     @Arg('name') name: string,
     @Arg('patch', type => ClaimOrderPatch) patch: ClaimOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimOrder> {
     const repository = getRepository(ClaimOrder)
     const claimOrder = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     return await repository.save({
@@ -39,7 +42,7 @@ export class ClaimOrderMutation {
   @Mutation(returns => [ClaimOrder])
   async updateMultipleClaimOrder(
     @Arg('patches', type => [ClaimOrderPatch]) patches: ClaimOrderPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ClaimOrder[]> {
     let results: ClaimOrder[] = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
@@ -63,7 +66,7 @@ export class ClaimOrderMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const claimOrder = await claimOrderRepo.findOne(newRecord.id)
+        const claimOrder = await claimOrderRepo.findOneBy({ id: newRecord.id })
 
         const result = await claimOrderRepo.save({
           ...claimOrder,
@@ -79,15 +82,18 @@ export class ClaimOrderMutation {
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaimOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    await getRepository(ClaimOrder).delete({ domain: context.state.domain, name })
+  async deleteClaimOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    await getRepository(ClaimOrder).delete({ domain: { id: context.state.domain.id }, name })
     return true
   }
 
   @Mutation(returns => Boolean)
-  async deleteClaimOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteClaimOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     await getRepository(ClaimOrder).delete({
-      domain: context.state.domain,
+      domain: { id: context.state.domain.id },
       name: In(names)
     })
     return true

package/server/service/claim-order/claim-order-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { ClaimOrderList } from '../'
 import { ClaimOrder } from './claim-order'
 
@@ -22,24 +23,25 @@ export class ClaimOrderQuery {
   }
 
   @Query(returns => ClaimOrder)
-  async claimOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ClaimOrder> {
+  async claimOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ClaimOrder> {
     return await getRepository(ClaimOrder).findOne({
-      where: { domain: context.state.domain, name, relations: ['domain', 'creator', 'updater'] }
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() claimOrder: ClaimOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(claimOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: claimOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() claimOrder: ClaimOrder): Promise<User> {
-    return await getRepository(User).findOne(claimOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: claimOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() claimOrder: ClaimOrder): Promise<User> {
-    return await getRepository(User).findOne(claimOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: claimOrder.updaterId })
   }
 }