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

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

@@ -1,27 +1,27 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getPermittedBizplaceIds } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product, ProductDetail } from '@things-factory/product-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
 import { Inventory, INVENTORY_STATUS } from '@things-factory/warehouse-base'
 
 import { ORDER_VAS_STATUS } from '../../constants'
 import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
 import { ReverseKittingOrder } from './reverse-kitting-order'
-import { LotInfo, ReverseKittingOrderList, ReverseKittingInventoryDetail } from './reverse-kitting-order-type'
+import { LotInfo, ReverseKittingInventoryDetail, ReverseKittingOrderList } from './reverse-kitting-order-type'
 
 @Resolver(ReverseKittingOrder)
 export class ReverseKittingOrderQuery {
   @Query(returns => ReverseKittingOrder, { description: 'To fetch a ReverseKittingOrder' })
-  async reverseKittingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ReverseKittingOrder> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async reverseKittingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ReverseKittingOrder> {
+    const { domain, user } = context.state
 
     return await getRepository(ReverseKittingOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       },
@@ -44,7 +44,7 @@ export class ReverseKittingOrderQuery {
   async reverseKittingInventories(
     @Arg('reverseKittingOIName') reverseKittingOIName: string,
     @Arg('productDetailId') productDetailId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Inventory[]> {
     const { domain } = context.state
 
@@ -59,7 +59,7 @@ export class ReverseKittingOrderQuery {
       ReverseKittingOrderInventory
     ).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name: reverseKittingOIName,
         status: ORDER_VAS_STATUS.PROCESSING
       },
@@ -72,7 +72,7 @@ export class ReverseKittingOrderQuery {
     const customerBizplace: Bizplace = foundReverseKittingOI.bizplace
     return await getRepository(Inventory).find({
       where: {
-        domain,
+        domain: { id: domain.id },
         bizplace: customerBizplace,
         refOrderId: reverseKittingOrder.id,
         orderVasId: foundReverseKittingOI.id,
@@ -89,7 +89,7 @@ export class ReverseKittingOrderQuery {
   async generateReverseKittingLotId(
     @Arg('targets', type => [LotInfo]) targets: LotInfo[],
     @Arg('type') type: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingInventoryDetail[]> {
     const { tx, domain } = context.state
     // 1. get and set the date
@@ -113,7 +113,7 @@ export class ReverseKittingOrderQuery {
       .getRepository(ReverseKittingOrderInventory)
       .find({
         where: {
-          domain,
+          domain: { id: domain.id },
           id: In(ids)
         },
         relations: ['domain', 'bizplace']
@@ -156,8 +156,11 @@ export class ReverseKittingOrderQuery {
   }
 
   @Query(returns => ReverseKittingOrderList, { description: 'To fetch multiple ReverseKittingOrders' })
-  async reverseKittingOrders(@Args() params: ListParam, @Ctx() context: any): Promise<ReverseKittingOrderList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async reverseKittingOrders(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<ReverseKittingOrderList> {
+    const { domain, user } = context.state
 
     const convertedParams = convertListParams(params)
     convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
@@ -179,16 +182,16 @@ export class ReverseKittingOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(reverseKittingOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: reverseKittingOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
-    return await getRepository(User).findOne(reverseKittingOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: reverseKittingOrder.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() reverseKittingOrder: ReverseKittingOrder): Promise<User> {
-    return await getRepository(User).findOne(reverseKittingOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: reverseKittingOrder.creatorId })
   }
 }

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

@@ -1,4 +1,4 @@
-import { Field, ID, ObjectType, Float, Int } from 'type-graphql'
+import { Field, Float, ID, Int, ObjectType } from 'type-graphql'
 import {
   Column,
   CreateDateColumn,
@@ -13,9 +13,9 @@ import {
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
+import { Product } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 import { Location } from '@things-factory/warehouse-base'
-import { Product } from '@things-factory/product-base'
 
 import { ReverseKittingOrderInventory } from '../reverse-kitting-order-inventory/reverse-kitting-order-inventory'
 

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

@@ -15,7 +15,7 @@ export class ReverseKittingOrderInventoryMutation {
   @Mutation(returns => ReverseKittingOrderInventory, { description: 'To create new ReverseKittingOrderInventory' })
   async createReverseKittingOrderInventory(
     @Arg('reverseKittingOrderInventory') reverseKittingOrderInventory: NewReverseKittingOrderInventory,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrderInventory> {
     const { domain, user, tx } = context.state
 
@@ -34,14 +34,14 @@ export class ReverseKittingOrderInventoryMutation {
   async updateReverseKittingOrderInventory(
     @Arg('id') id: string,
     @Arg('patch') patch: ReverseKittingOrderInventoryPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrderInventory> {
     const { tx, user, domain } = context.state
     const reverseKittingOI: ReverseKittingOrderInventory = await tx
       .getRepository(ReverseKittingOrderInventory)
       .findOne({
         where: {
-          domain,
+          domain: { id: domain.id },
           bizplace: In(await getPermittedBizplaceIds(domain, user)),
           id
         }
@@ -60,7 +60,7 @@ export class ReverseKittingOrderInventoryMutation {
   })
   async updateMultipleReverseKittingOrderInventory(
     @Arg('patches', type => [ReverseKittingOrderInventoryPatch]) patches: ReverseKittingOrderInventoryPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrderInventory[]> {
     const { domain, user, tx } = context.state
 
@@ -87,7 +87,7 @@ export class ReverseKittingOrderInventoryMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const reverseKittingOrderInventory = await reverseKittingOrderInventoryRepo.findOne(newRecord.id)
+        const reverseKittingOrderInventory = await reverseKittingOrderInventoryRepo.findOneBy({ id: newRecord.id })
 
         const result = await reverseKittingOrderInventoryRepo.save({
           ...reverseKittingOrderInventory,
@@ -104,10 +104,10 @@ export class ReverseKittingOrderInventoryMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete ReverseKittingOrderInventory' })
-  async deleteReverseKittingOrderInventory(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteReverseKittingOrderInventory(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(ReverseKittingOrderInventory).delete({ domain, id })
+    await tx.getRepository(ReverseKittingOrderInventory).delete({ domain: { id: domain.id }, id })
     return true
   }
 
@@ -115,12 +115,12 @@ export class ReverseKittingOrderInventoryMutation {
   @Mutation(returns => Boolean, { description: 'To delete multiple reverseKittingOrderInventorys' })
   async deleteReverseKittingOrderInventories(
     @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(ReverseKittingOrderInventory).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

package/server/service/reverse-kitting-order-inventory/reverse-kitting-order-inventory-query.ts

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
 
 import { ReverseKittingOrderInventory } from './reverse-kitting-order-inventory'
 import { ReverseKittingOrderInventoryList } from './reverse-kitting-order-inventory-type'
@@ -12,12 +11,12 @@ export class ReverseKittingOrderInventoryQuery {
   @Query(returns => ReverseKittingOrderInventory, { description: 'To fetch a ReverseKittingOrderInventory' })
   async reverseKittingOrderInventory(
     @Arg('id') id: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrderInventory> {
     const { domain } = context.state
 
     return await getRepository(ReverseKittingOrderInventory).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
@@ -26,7 +25,7 @@ export class ReverseKittingOrderInventoryQuery {
   })
   async reverseKittingOrderInventories(
     @Args() params: ListParam,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ReverseKittingOrderInventoryList> {
     const { domain } = context.state
 
@@ -38,16 +37,16 @@ export class ReverseKittingOrderInventoryQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<Domain> {
-    return await getRepository(Domain).findOne(reverseKittingOrderInventory.domainId)
+    return await getRepository(Domain).findOneBy({ id: reverseKittingOrderInventory.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
-    return await getRepository(User).findOne(reverseKittingOrderInventory.updaterId)
+    return await getRepository(User).findOneBy({ id: reverseKittingOrderInventory.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() reverseKittingOrderInventory: ReverseKittingOrderInventory): Promise<User> {
-    return await getRepository(User).findOne(reverseKittingOrderInventory.creatorId)
+    return await getRepository(User).findOneBy({ id: reverseKittingOrderInventory.creatorId })
   }
 }

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

@@ -1,9 +1,9 @@
-import { User } from '@things-factory/auth-base'
-import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 import { v4 as uuidv4 } from 'uuid'
+
+import { getPermittedBizplaceIds } from '@things-factory/biz-base'
+
 import { NewShippingOrder, ShippingOrderPatch } from '../'
 import { ShippingOrder } from './shipping-order'
 
@@ -13,9 +13,9 @@ export class ShippingOrderMutation {
   @Mutation(returns => ShippingOrder)
   async createShippingOrder(
     @Arg('shippingOrder', type => NewShippingOrder) shippingOrder: NewShippingOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ShippingOrder> {
-    const { tx }: { tx: EntityManager } = context.state
+    const { tx } = context.state
 
     const repository = tx.getRepository(ShippingOrder)
     const newShippingOrder = {
@@ -31,13 +31,13 @@ export class ShippingOrderMutation {
   async updateShippingOrder(
     @Arg('name') name: string,
     @Arg('patch', type => ShippingOrderPatch) patch: ShippingOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<ShippingOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const shippingOrder = await tx.getRepository(ShippingOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       }
@@ -52,8 +52,8 @@ export class ShippingOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteShippingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteShippingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(ShippingOrder).delete({ domain, name })
     return true

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

@@ -1,8 +1,10 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { In } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { getPermittedBizplaceIds } from '@things-factory/biz-base'
-import { convertListParams, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { convertListParams, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { ShippingOrderList } from '../'
 import { ShippingOrder } from './shipping-order'
 
@@ -10,12 +12,12 @@ import { ShippingOrder } from './shipping-order'
 export class ShippingOrderQuery {
   @Query(returns => ShippingOrderList)
   async shippingOrders(
-    @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<ShippingOrderList> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+    const { domain, user } = context.state
 
     const convertedParams = convertListParams({ filters, pagination, sortings })
     convertedParams.where.bizplace = In(await getPermittedBizplaceIds(domain, user))
@@ -29,12 +31,12 @@ export class ShippingOrderQuery {
   }
 
   @Query(returns => ShippingOrder)
-  async shippingOrder(@Arg('name') name: string, @Ctx() context: any): Promise<ShippingOrder> {
-    const { domain, user }: { domain: Domain; user: User } = context.state
+  async shippingOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<ShippingOrder> {
+    const { domain, user } = context.state
 
     return await getRepository(ShippingOrder).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name,
         bizplace: In(await getPermittedBizplaceIds(domain, user))
       },
@@ -44,16 +46,16 @@ export class ShippingOrderQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() shippingOrder: ShippingOrder): Promise<Domain> {
-    return await getRepository(Domain).findOne(shippingOrder.domainId)
+    return await getRepository(Domain).findOneBy({ id: shippingOrder.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() shippingOrder: ShippingOrder): Promise<User> {
-    return await getRepository(User).findOne(shippingOrder.creatorId)
+    return await getRepository(User).findOneBy({ id: shippingOrder.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() shippingOrder: ShippingOrder): Promise<User> {
-    return await getRepository(User).findOne(shippingOrder.updaterId)
+    return await getRepository(User).findOneBy({ id: shippingOrder.updaterId })
   }
 }

package/server/service/shipping-order/shipping-order-types.ts

@@ -54,21 +54,36 @@ export class ShippingOrderPatch {
   @Field({ nullable: true })
   containerNo: string
 
+  @Field({ nullable: true })
+  containerSize: string
+
   @Field({ nullable: true })
   containerArrivalDate: string
 
   @Field({ nullable: true })
   containerLeavingDate: string
 
+  @Field({ nullable: true })
+  containerClosureDate: string
+
   @Field({ nullable: true })
   containerArrivalDateTime: string
 
   @Field({ nullable: true })
-  containerLeavingDateTime: string
+  containerLeavingDateTime: Date
+
+  @Field({ nullable: true })
+  containerClosureDateTime: Date
 
   @Field({ nullable: true })
   remark: string
 
+  @Field({ nullable: true })
+  exportRemark: string
+
   @Field({ nullable: true })
   status: string
+
+  @Field({ nullable: true })
+  remindContainerDeparture: boolean
 }

package/server/service/shipping-order/shipping-order.ts

@@ -41,14 +41,18 @@ export class ShippingOrder {
   @Field()
   name: string
 
-  @Column()
-  @Field()
+  @Column({ nullable: true })
+  @Field({ nullable: true })
   shipName: string
 
   @Column()
   @Field()
   containerNo: string
 
+  @Column({ nullable: true })
+  @Field()
+  containerSize: string
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   containerArrivalDate: string
@@ -65,6 +69,18 @@ export class ShippingOrder {
   @Field({ nullable: true })
   containerLeavingDateTime: Date
 
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerClosureDate: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  containerClosureDateTime: Date
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  remindContainerDeparture: boolean
+
   @Column({ nullable: true })
   @Field({ nullable: true })
   from: string

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

@@ -1,11 +1,13 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { EntityManager, In, Repository } from 'typeorm'
+
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getOutletBizplace } from '@things-factory/biz-base'
 import { generateId } from '@things-factory/id-rule-base'
 import { Product } from '@things-factory/product-base'
 import { Setting } from '@things-factory/setting-base'
-import { Domain } from '@things-factory/shell'
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getRepository, In, Repository } from 'typeorm'
+import { Domain, getRepository } from '@things-factory/shell'
+
 import { NewOrderInventory, NewTransferOrder, OrderInventory, RetailReplenishmentOrder, TransferOrderPatch } from '../'
 import {
   ORDER_INVENTORY_STATUS,
@@ -24,9 +26,9 @@ export class TransferOrderMutation {
   async addTransferOrderInventories(
     @Arg('toNo') toNo: string,
     @Arg('orderInventories', type => [NewOrderInventory]) orderInventories: NewOrderInventory[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
       where: { name: toNo },
@@ -41,14 +43,14 @@ export class TransferOrderMutation {
   @Mutation(returns => TransferOrder)
   async cancelTransferOrder(
     @Arg('patch', type => TransferOrderPatch) patch: TransferOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<TransferOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const bizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
 
     const transferOrder: TransferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { domain, bizplace, name: patch.name },
+      where: { domain: { id: domain.id }, bizplace, name: patch.name },
       relations: ['bizplace', 'orderInventories']
     })
 
@@ -81,9 +83,9 @@ export class TransferOrderMutation {
   @Mutation(returns => TransferOrder)
   async createTransferOrder(
     @Arg('transferOrder', type => NewTransferOrder) transferOrder: NewTransferOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<TransferOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     let orderInventories: NewOrderInventory[] = transferOrder.orderInventories
     const myBizplace: Bizplace = await getOutletBizplace(transferOrder.warehouseId)
@@ -92,7 +94,7 @@ export class TransferOrderMutation {
     const retailReplenishmentOrder: RetailReplenishmentOrder = await tx
       .getRepository(RetailReplenishmentOrder)
       .findOne({
-        where: { domain, bizplace: myBizplace, refNo: transferOrder.refNo },
+        where: { domain: { id: domain.id }, bizplace: myBizplace, refNo: transferOrder.refNo },
         relations: ['domain', 'bizplace']
       })
 
@@ -126,9 +128,9 @@ export class TransferOrderMutation {
   @Mutation(returns => Boolean)
   async generateTransferOrder(
     @Arg('transferOrder', type => NewTransferOrder) transferOrder: NewTransferOrder,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     await generateTransferOrder(transferOrder, domain, user, tx)
     return true
@@ -138,9 +140,9 @@ export class TransferOrderMutation {
   @Mutation(returns => TransferOrder)
   async completeTransferOrder(
     @Arg('patch', type => TransferOrderPatch) patch: TransferOrderPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<TransferOrder> {
-    const { tx, domain, user }: { tx: EntityManager; domain: Domain; user: User } = context.state
+    const { tx, domain, user } = context.state
 
     const myBizplace: Bizplace = await getOutletBizplace(patch.warehouseId)
     let targetOIs: NewOrderInventory[] = patch.orderInventories
@@ -148,7 +150,7 @@ export class TransferOrderMutation {
 
     // #1 Find Transfer Order
     const foundTO: TransferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { domain, name: patch.name, bizplace: myBizplace },
+      where: { domain: { id: domain.id }, name: patch.name, bizplace: myBizplace },
       relations: ['bizplace', 'orderInventories']
     })
 
@@ -158,7 +160,7 @@ export class TransferOrderMutation {
 
     // #2 Find related order inventories
     let foundOIs: OrderInventory[] = await tx.getRepository(OrderInventory).find({
-      where: { domain, transferOrder: foundTO }
+      where: { domain: { id: domain.id }, transferOrder: { id: foundTO.id } }
     })
 
     if (!foundOIs) throw new Error(`Order inventories were not found.`)
@@ -189,8 +191,8 @@ export class TransferOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteTransferOrder(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteTransferOrder(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(TransferOrder).delete({ domain, name })
     return true
@@ -198,10 +200,13 @@ export class TransferOrderMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteTransferOrders(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteTransferOrders(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
     await tx.getRepository(TransferOrder).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true
@@ -221,14 +226,18 @@ export async function addTransferOrderInventories(
 
   if (!transferOrder?.bizplace || !transferOrder?.orderInventories?.length) {
     transferOrder = await tx.getRepository(TransferOrder).findOne({
-      where: { ...transferOrder },
+      where: { id: transferOrder.id } /* CONFIRMME regarding TYPEORM */,
       relations: ['bizplace', 'orderInventories']
     })
   }
 
   orderInventories = await Promise.all(
     orderInventories.map(async (oi: OrderInventory) => {
-      const foundProduct: Product = await productRepo.findOne({ domain, sku: oi.product.sku, name: oi.product.name })
+      const foundProduct: Product = await productRepo.findOneBy({
+        domain: { id: domain.id },
+        sku: oi.product.sku,
+        name: oi.product.name
+      })
       return {
         ...oi,
         domain,
@@ -264,7 +273,7 @@ export async function generateTransferOrder(
   // find TO number rule setting
   const toNoSetting: Setting = await settingRepo.findOne({
     where: {
-      domain,
+      domain: { id: domain.id },
       name: ORDER_NUMBER_SETTING_KEY.TO_NUMBER_RULE
     }
   })