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

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

@@ -4,11 +4,9 @@ import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { EntityManager, In } from 'typeorm'
 
 import { Attachment, createAttachments } from '@things-factory/attachment-base'
-import { Role, User } from '@things-factory/auth-base'
+import { Role } from '@things-factory/auth-base'
 import { Bizplace, getDomainUsers } from '@things-factory/biz-base'
-import { sendNotification } from '@things-factory/notification'
 import { Product } from '@things-factory/product-base'
-import { Domain } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
 
 import { NewOrderInventory, NewReturnOrder, OrderInventory, OrderVas, ReturnOrderPatch } from '../'
@@ -21,8 +19,8 @@ export class ReturnOrderMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteReturnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx } = context.state
 
     return await deleteReturnOrder(tx, name, context)
   }
@@ -30,11 +28,14 @@ export class ReturnOrderMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteReturnOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteReturnOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(ReturnOrder).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true
@@ -44,13 +45,13 @@ export class ReturnOrderMutation {
   @Directive('@transaction')
   @Mutation(returns => ReturnOrder)
   async generateReturnOrder(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('file', type => [GraphQLUpload], { nullable: true }) file: FileUpload[],
     @Arg('returnOrder', type => NewReturnOrder, { nullable: true }) returnOrder: NewReturnOrder
   ): Promise<ReturnOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
-    const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(returnOrder.customerBizplaceId)
+    const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: returnOrder.customerBizplaceId })
 
     let orderInventories: NewOrderInventory[] = returnOrder.orderInventories
     let foundInv = Inventory
@@ -90,7 +91,7 @@ export class ReturnOrderMutation {
       throw new Error('invalid return quantity')
     }
 
-    let createdReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save(newReturnOrder)
+    let createdReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).save(newReturnOrder as any)
 
     for (let moi of mergedOrderInventories) {
       let newOrderInv: OrderInventory = Object.assign({}, moi) as any
@@ -99,12 +100,12 @@ export class ReturnOrderMutation {
       newOrderInv.status = ORDER_INVENTORY_STATUS.PENDING
       newOrderInv.name = OrderNoGenerator.orderInventory()
       newOrderInv.returnOrder = createdReturnOrder
-      newOrderInv.product = await tx.getRepository(Product).findOne(moi.product.id)
+      newOrderInv.product = await tx.getRepository(Product).findOneBy({ id: moi.product.id })
       newOrderInv.creator = user
       newOrderInv.updater = user
 
       if (newOrderInv.inventory?.id) {
-        foundInv = await tx.getRepository(Inventory).findOne(newOrderInv.inventory.id)
+        foundInv = await tx.getRepository(Inventory).findOneBy({ id: newOrderInv.inventory.id })
         newOrderInv.inventory = foundInv
       }
 
@@ -129,8 +130,8 @@ export class ReturnOrderMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReturnOrder)
-  async confirmReturnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrder> {
-    const { tx }: { tx: EntityManager } = context.state
+  async confirmReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
 
     const returnOrder: ReturnOrder = await confirmReturnOrder(tx, name, context)
 
@@ -140,8 +141,8 @@ export class ReturnOrderMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReturnOrder)
-  async receiveReturnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrder> {
-    const { tx }: { tx: EntityManager } = context.state
+  async receiveReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
     const returnOrder: ReturnOrder = await receiveReturnOrder(tx, name, context)
 
     return returnOrder
@@ -153,9 +154,9 @@ export class ReturnOrderMutation {
   async rejectReturnOrder(
     @Arg('name') name: string,
     @Arg('patch', type => ReturnOrderPatch) patch: ReturnOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReturnOrder> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
     const returnOrder: ReturnOrder = await rejectReturnOrder(tx, name, patch.remark, context)
 
     return returnOrder
@@ -164,19 +165,19 @@ export class ReturnOrderMutation {
   @Directive('@privilege(category: "order_customer", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => ReturnOrder)
-  async checkReturnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrder> {
-    const { tx }: { tx: EntityManager } = context.state
+  async checkReturnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { tx } = context.state
     const returnOrder: ReturnOrder = await checkReturnOrder(tx, name, context)
 
     return returnOrder
   }
 }
 
-export async function deleteReturnOrder(tx: EntityManager, name: string, context: any): Promise<boolean> {
-  const { domain }: { domain: Domain } = context.state
+export async function deleteReturnOrder(tx: EntityManager, name: string, context: ResolverContext): Promise<boolean> {
+  const { domain } = context.state
 
   let foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name },
+    where: { domain: { id: domain.id }, name },
     relations: ['orderInventories', 'orderInventories.inventory', 'orderVass', 'creator', 'updater']
   })
 
@@ -188,7 +189,7 @@ export async function deleteReturnOrder(tx: EntityManager, name: string, context
   if (foundReturnOrder?.ownTransport) {
     foundAttachment = await tx.getRepository(Attachment).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         refBy: foundReturnOrder.id,
         category: ATTACHMENT_TYPE.RETURN_ORDER
       }
@@ -217,11 +218,15 @@ export async function deleteReturnOrder(tx: EntityManager, name: string, context
   return true
 }
 
-export async function confirmReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+export async function confirmReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
 
   const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
     relations: ['bizplace', 'orderInventories', 'orderVass']
   })
 
@@ -286,21 +291,28 @@ export async function confirmReturnOrder(tx: EntityManager, name: string, contex
       url: context.header.referer,
       data: { url: context.header.referer }
     }
-
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message: { ...msg }
+    // })
   }
 
   return returnOrder
 }
 
-export async function receiveReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+export async function receiveReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
 
   const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
     relations: ['bizplace', 'orderInventories', 'orderVass']
   })
 
@@ -351,10 +363,14 @@ export async function receiveReturnOrder(tx: EntityManager, name: string, contex
       data: { url: context.header.referer }
     }
 
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message: { ...msg }
+    // })
   }
 
   return returnOrder
@@ -366,10 +382,10 @@ export async function rejectReturnOrder(
   remark: string,
   context: any
 ): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+  const { domain, user } = context.state
 
   const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.PENDING_RECEIVE },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING_RECEIVE },
     relations: ['bizplace', 'orderInventories', 'orderVass']
   })
 
@@ -418,20 +434,28 @@ export async function rejectReturnOrder(
       data: { url: context.header.referer }
     }
 
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message: { ...msg }
+    // })
   }
 
   return foundReturnOrder
 }
 
-export async function checkReturnOrder(tx: EntityManager, name: string, context: any): Promise<ReturnOrder> {
-  const { domain, user }: { domain: Domain; user: User } = context.state
+export async function checkReturnOrder(
+  tx: EntityManager,
+  name: string,
+  context: ResolverContext
+): Promise<ReturnOrder> {
+  const { domain, user } = context.state
 
   const foundReturnOrder: ReturnOrder = await tx.getRepository(ReturnOrder).findOne({
-    where: { domain, name, status: ORDER_STATUS.INTRANSIT },
+    where: { domain: { id: domain.id }, name, status: ORDER_STATUS.INTRANSIT },
     relations: ['bizplace', 'orderInventories', 'orderVass']
   })
 
@@ -478,10 +502,14 @@ export async function checkReturnOrder(tx: EntityManager, name: string, context:
       data: { url: context.header.referer }
     }
 
-    await sendNotification({
-      receivers,
-      message: { ...msg }
-    })
+    /**
+     * @notes Temporary off sendNotification due to suspect of causing wms down
+     */
+
+    // await sendNotification({
+    //   receivers,
+    //   message: { ...msg }
+    // })
   }
 
   return foundReturnOrder

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

@@ -1,10 +1,12 @@
+import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { OrderByCondition, SelectQueryBuilder } from 'typeorm'
+
 import { Attachment } from '@things-factory/attachment-base'
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
 import { Inventory } from '@things-factory/warehouse-base'
-import { Arg, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, SelectQueryBuilder } from 'typeorm'
+
 import { OrderInventory, ReturnOrderDetail, ReturnOrderList } from '../'
 import { ATTACHMENT_TYPE, ORDER_INVENTORY_TYPE, ORDER_STATUS } from '../../constants'
 import { ReturnOrder } from './return-order'
@@ -13,13 +15,13 @@ import { ReturnOrder } from './return-order'
 export class ReturnOrderQuery {
   @Query(returns => ReturnOrderList)
   async returnOrders(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<ReturnOrderList> {
     try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      const { domain, user } = context.state
 
       filters.push({
         name: 'bizplaceId',
@@ -46,7 +48,7 @@ export class ReturnOrderQuery {
       qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
 
       const arrChildSortData = ['bizplace']
-      const sort = (sortings || []).reduce(
+      const sort: OrderByCondition = (sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
           [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
@@ -67,24 +69,24 @@ export class ReturnOrderQuery {
   }
 
   @Query(returns => ReturnOrder)
-  async returnOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrder> {
-    const { domain }: { domain: Domain } = context.state
+  async returnOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrder> {
+    const { domain } = context.state
 
     const repository = getRepository(ReturnOrder)
 
     return await repository.findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['domain', 'creator', 'updater']
     })
   }
 
   @Query(returns => ReturnOrderDetail)
-  async returnOrderDetail(@Arg('name') name: string, @Ctx() context: any): Promise<ReturnOrderDetail> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async returnOrderDetail(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReturnOrderDetail> {
+    const { domain, user } = context.state
 
     const returnOrder: ReturnOrder = await getRepository(ReturnOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name
       },
       relations: [
@@ -106,7 +108,7 @@ export class ReturnOrderQuery {
 
     const foundAttachments: Attachment[] = await getRepository(Attachment).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         refBy: returnOrder.id,
         category: ATTACHMENT_TYPE.RETURN_ORDER
       }
@@ -140,13 +142,13 @@ export class ReturnOrderQuery {
   @Directive('@privilege(category: "order_warehouse", privilege: "query")')
   @Query(returns => ReturnOrderList)
   async returnOrderRequests(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('filters', type => [Filter], { nullable: true }) filters?: Filter[],
     @Arg('pagination', type => Pagination, { nullable: true }) pagination?: Pagination,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<ReturnOrderList> {
     try {
-      const { domain, user }: { domain: Domain; user: User } = context.state
+      const { domain, user } = context.state
 
       const statusFilter = filters.some(e => e.name === 'status')
       const bizplaceFilter = filters.find(param => param.name === 'bizplaceId')
@@ -187,7 +189,7 @@ export class ReturnOrderQuery {
       qb.leftJoinAndSelect('ro.acceptedBy', 'acceptedBy')
 
       const arrChildSortData = ['bizplace']
-      const sort = (sortings || []).reduce(
+      const sort: OrderByCondition = (sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
           [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ro.' + sort.name]: sort.desc
@@ -209,16 +211,16 @@ export class ReturnOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() returnOrder: ReturnOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(returnOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: returnOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() returnOrder: ReturnOrder): Promise<User> {
-    return await getRepository(User).findOne(returnOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: returnOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() returnOrder: ReturnOrder): Promise<User> {
-    return await getRepository(User).findOne(returnOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: returnOrder.updaterId })
   }
 }

package/server/service/reverse-kitting-order/reverse-kitting-order-mutation.ts

@@ -15,9 +15,8 @@ import {
   Warehouse
 } from '@things-factory/warehouse-base'
 
-import { InventoryUtil } from '../../utils'
-
 import { ORDER_STATUS, ORDER_TYPES, ORDER_VAS_STATUS } from '../../constants'
+import { InventoryUtil } from '../../utils'
 import { OrderNoGenerator } from '../../utils/order-no-generator'
 import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
 import { ReverseKittingOrder } from './reverse-kitting-order'
@@ -29,7 +28,7 @@ export class ReverseKittingOrderMutation {
   @Mutation(returns => ReverseKittingOrder, { description: 'To create new ReverseKittingOrder' })
   async generateReverseKittingOrder(
     @Arg('reverseKittingOrder', type => NewReverseKittingOrder) reverseKittingOrder: NewReverseKittingOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrder> {
     const { tx, domain, user } = context.state
 
@@ -55,7 +54,7 @@ export class ReverseKittingOrderMutation {
     reverseKittingOrderOIs = await Promise.all(
       reverseKittingOrderOIs.map(async (reverseKittingOI: any) => {
         if (reverseKittingOI?.inventory?.id) {
-          const foundInv: Inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+          const foundInv: Inventory = await tx.getRepository(Inventory).findOneBy({ id: reverseKittingOI.inventory.id })
           reverseKittingOI.inventory = foundInv
 
           foundInv.lockedQty = Number(foundInv.lockedQty) + reverseKittingOI.qty
@@ -83,12 +82,15 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To execute reverse kitting order' })
-  async executingReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+  async executingReverseKittingOrder(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrder> {
     const { domain, user, tx } = context.state
 
     const reverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         status: ORDER_STATUS.EXECUTING,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
@@ -113,11 +115,14 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To confirm reverse kitting order' })
-  async confirmReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+  async confirmReverseKittingOrder(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrder> {
     const { user, domain, tx } = context.state
 
     const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain, name, status: ORDER_STATUS.PENDING },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.PENDING },
       relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
     })
 
@@ -142,11 +147,11 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To confirm reverse kitting order' })
-  async completeReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+  async completeReverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx, domain, user } = context.state
 
     let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain, name, status: ORDER_STATUS.EXECUTING },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.EXECUTING },
       relations: [
         'bizplace',
         'reverseKittingOrderInventories',
@@ -200,11 +205,14 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To cancel reverse kitting order' })
-  async cancelReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+  async cancelReverseKittingOrder(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrder> {
     const { user, domain, tx } = context.state
 
     const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.READY_TO_EXECUTE },
       relations: [
         'bizplace',
         'reverseKittingOrderInventories',
@@ -228,7 +236,9 @@ export class ReverseKittingOrderMutation {
     reverseKittingOIs = await Promise.all(
       reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
         if (reverseKittingOI?.inventory?.id) {
-          reverseKittingOI.inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+          reverseKittingOI.inventory = await tx
+            .getRepository(Inventory)
+            .findOneBy({ id: reverseKittingOI.inventory.id })
 
           await tx.getRepository(Inventory).save({
             ...reverseKittingOI.inventory,
@@ -251,7 +261,7 @@ export class ReverseKittingOrderMutation {
   async undoReverseKittingInventory(
     @Arg('reverseKittingOIName') reverseKittingOIName: string,
     @Arg('palletId') palletId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { tx, domain, user } = context.state
 
@@ -260,14 +270,14 @@ export class ReverseKittingOrderMutation {
     const reverseKittingOI: ReverseKittingOrderInventory = await tx
       .getRepository(ReverseKittingOrderInventory)
       .findOne({
-        where: { domain, name: reverseKittingOIName },
+        where: { domain: { id: domain.id }, name: reverseKittingOIName },
         relations: ['bizplace', 'reverseKittingOrder']
       })
 
     const bizplace: Bizplace = reverseKittingOI.bizplace
     const reverseKittingOrder: ReverseKittingOrder = reverseKittingOI.reverseKittingOrder
     let foundInventory: Inventory = await tx.getRepository(Inventory).findOne({
-      where: { domain, bizplace, orderVasId: reverseKittingOI.id, palletId },
+      where: { domain: { id: domain.id }, bizplace, orderVasId: reverseKittingOI.id, palletId },
       relations: ['bizplace', 'product']
     })
     if (!foundInventory) throw new Error(`There's no results matched with condition ${foundInventory.palletId}`)
@@ -310,11 +320,14 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => ReverseKittingOrder, { description: 'To activate reverse kitting order' })
-  async activateReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
+  async activateReverseKittingOrder(
+    @Arg('name') name: string,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrder> {
     const { user, domain, tx } = context.state
 
     const foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain, name, status: ORDER_STATUS.READY_TO_EXECUTE },
+      where: { domain: { id: domain.id }, name, status: ORDER_STATUS.READY_TO_EXECUTE },
       relations: ['bizplace', 'reverseKittingOrderInventories', 'creator', 'updater']
     })
 
@@ -342,7 +355,7 @@ export class ReverseKittingOrderMutation {
   async executeReverseKitting(
     @Arg('name') name: string,
     @Arg('inventory', type => InventoryPatch) inventory: Partial<Inventory>,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { user, domain, tx } = context.state
 
@@ -367,7 +380,7 @@ export class ReverseKittingOrderMutation {
 
     const location: Location = await tx.getRepository(Location).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: inventory.locationName,
         type: In([LOCATION_TYPE.SHELF, LOCATION_TYPE.BUFFER, LOCATION_TYPE.FLOOR])
       },
@@ -437,10 +450,10 @@ export class ReverseKittingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrder' })
-  async deleteReverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
+  async deleteReverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx, user } = context.state
     let foundReverseKittingOrder: ReverseKittingOrder = await tx.getRepository(ReverseKittingOrder).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: [
         'bizplace',
         'reverseKittingOrderInventories',
@@ -458,7 +471,9 @@ export class ReverseKittingOrderMutation {
     await Promise.all(
       reverseKittingOIs.map(async (reverseKittingOI: ReverseKittingOrderInventory) => {
         if (reverseKittingOI?.inventory?.id) {
-          reverseKittingOI.inventory = await tx.getRepository(Inventory).findOne(reverseKittingOI.inventory.id)
+          reverseKittingOI.inventory = await tx
+            .getRepository(Inventory)
+            .findOneBy({ id: reverseKittingOI.inventory.id })
 
           await tx.getRepository(Inventory).save({
             ...reverseKittingOI.inventory,