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

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

@@ -10,6 +10,7 @@ import {
   Entity,
   Index,
   ManyToOne,
+  OneToMany,
   PrimaryGeneratedColumn,
   RelationId,
   UpdateDateColumn
@@ -28,6 +29,7 @@ import { ArrivalNotice } from '../arrival-notice/arrival-notice'
 import { DeliveryOrder } from '../delivery-order/delivery-order'
 import { InventoryCheck } from '../inventory-check/inventory-check'
 import { OrderProduct } from '../order-product/order-product'
+import { OrderToteItem } from '../order-tote-item/order-tote-item'
 import { ReleaseGood } from '../release-good/release-good'
 import { ReturnOrder } from '../return-order/return-order'
 import { TransferOrder } from '../transfer-order/transfer-order'
@@ -70,6 +72,7 @@ import { TransferOrder } from '../transfer-order/transfer-order'
   orderInventory.releaseQty,
   orderInventory.uom
 ])
+@Index('ix_order-inventory_5', (orderInventory: OrderInventory) => [orderInventory.releaseGood])
 @ObjectType()
 export class OrderInventory {
   @PrimaryGeneratedColumn('uuid')
@@ -190,6 +193,10 @@ export class OrderInventory {
   @RelationId((orderInventory: OrderInventory) => orderInventory.orderProduct)
   orderProductId: string
 
+  @OneToMany(type => OrderToteItem, orderToteItem => orderToteItem.orderInventory, { nullable: true })
+  @Field(type => [OrderToteItem], { nullable: true })
+  orderToteItems: OrderToteItem[]
+
   @Column({ type: 'uuid', nullable: true })
   @Field({ nullable: true })
   refWorksheetId: string
@@ -342,9 +349,8 @@ export class OrderInventory {
   @Field({ nullable: true })
   loadedAt: Date
 
-  @Column({ nullable: true })
   @Field({ nullable: true })
-  shippedAt: Date
+  dispatchedAt: Date
 
   @CreateDateColumn()
   @Field()
@@ -409,4 +415,22 @@ export class OrderInventory {
 
   @Field({ nullable: true })
   extraJsonData: string
+
+  @Field({ nullable: true })
+  binNumber: string
+
+  @Field({ nullable: true })
+  toteNumber: string
+
+  @Field({ nullable: true })
+  routeId: string
+
+  @Field({ nullable: true })
+  storeId: string
+
+  @Field({ nullable: true })
+  storeName: string
+
+  @Field({ nullable: true })
+  stopId: string
 }

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

@@ -1,7 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { OrderProduct } from './order-product'
 import { OrderProductPatch } from './order-product-types'
@@ -11,14 +9,14 @@ export class OrderProductMutation {
   @Directive('@transaction')
   @Mutation(returns => OrderProduct)
   async updateOrderProduct(
-    @Ctx() context: any,
+    @Ctx() context: ResolverContext,
     @Arg('name') name: string,
     @Arg('patch', type => OrderProductPatch) patch: OrderProductPatch
   ): Promise<OrderProduct> {
     const { tx, domain, user } = context.state
 
     let foundOP: OrderProduct = await tx.getRepository(OrderProduct).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await tx.getRepository(OrderProduct).save({ ...foundOP, ...patch, updater: user })
@@ -26,8 +24,8 @@ export class OrderProductMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderProduct(@Arg('name') name: string, @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteOrderProduct(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(OrderProduct).delete({ domain, name })
     return true
@@ -35,11 +33,14 @@ export class OrderProductMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderProducts(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<boolean> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+  async deleteOrderProducts(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
 
     await tx.getRepository(OrderProduct).delete({
-      domain,
+      domain: { id: domain.id },
       name: In(names)
     })
     return true

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

@@ -1,7 +1,9 @@
-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 { Brackets, SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
+
 import { OrderProductList } from '../'
 import { OrderProduct } from './order-product'
 
@@ -9,44 +11,79 @@ import { OrderProduct } from './order-product'
 export class OrderProductQuery {
   @Query(returns => OrderProductList)
   async orderProducts(
-    @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<OrderProductList> {
-    const convertedParams = convertListParams({ filters, pagination, sortings })
-    const [items, total] = await getRepository(OrderProduct).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'bizplace', 'bizplace.company', 'arrivalNotice', 'product', 'creator', 'updater']
-    })
+    const { domain, user } = context.state
+    const params = { filters, pagination }
+
+    const releaseGoodFilters = params.filters.filter(x => x.name == 'releaseGood')
+    const productFilters = params.filters.filter(x => x.name == 'productInfo')
+    const productFilterColumns = ['sku', 'brand_sku', 'name', 'description', 'brand', 'sub_brand']
+    params.filters = params.filters.filter(x => x.name != 'productInfo')
+
+    let qb: SelectQueryBuilder<OrderProduct> = await getRepository(OrderProduct).createQueryBuilder('op')
+    qb.leftJoinAndSelect('op.product', 'product')
+      .leftJoinAndSelect('op.domain', 'domain')
+      .leftJoinAndSelect('op.bizplace', 'bizplace')
+      .leftJoinAndSelect('bizplace.company', 'company')
+      .leftJoinAndSelect('op.arrivalNotice', 'an')
+      .leftJoinAndSelect('op.releaseGood', 'rg')
+      .leftJoinAndSelect('op.creator', 'creator')
+      .leftJoinAndSelect('op.updater', 'updater')
+      .andWhere('op.domain_id = :domainId', { domainId: domain.id })
+      .andWhere('op.release_good_id IN (:...releaseGoodId)', { releaseGoodId: releaseGoodFilters[0].value })
+
+    if (productFilters && productFilters.length > 0) {
+      let productInfo = productFilters[0]
+      let productValue = productInfo.value
+        .toLowerCase()
+        .split(',')
+        .map(prod => {
+          return "'%" + prod.trim().replace(/'/g, "''") + "%'"
+        })
+        .join(',')
+      qb.andWhere(
+        new Brackets(qb2 => {
+          productFilterColumns.forEach(filter => {
+            qb2.orWhere(`Lower("product"."${filter}") LIKE ANY(ARRAY[${productValue}])`)
+          })
+        })
+      )
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
     return { items, total }
   }
 
   @Query(returns => OrderProduct)
-  async orderProduct(@Ctx() context: any, @Arg('name') name: string): Promise<OrderProduct> {
-    const { domain }: { domain: Domain } = context.state
+  async orderProduct(@Ctx() context: ResolverContext, @Arg('name') name: string): Promise<OrderProduct> {
+    const { domain } = context.state
 
     return await getRepository(OrderProduct).findOne({
       where: {
-        domain,
-        name,
-        relations: ['domain', 'arrivalNotice', 'product', 'creator', 'updater']
-      }
+        domain: { id: domain.id },
+        name
+      },
+      relations: ['domain', 'arrivalNotice', 'product', 'creator', 'updater']
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() orderProduct: OrderProduct): Promise<Domain> {
-    return await getRepository(Domain).findOne(orderProduct.domainId)
+    return await getRepository(Domain).findOneBy({ id: orderProduct.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() orderProduct: OrderProduct): Promise<User> {
-    return await getRepository(User).findOne(orderProduct.creatorId)
+    return await getRepository(User).findOneBy({ id: orderProduct.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() orderProduct: OrderProduct): Promise<User> {
-    return await getRepository(User).findOne(orderProduct.updaterId)
+    return await getRepository(User).findOneBy({ id: orderProduct.updaterId })
   }
 }

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

@@ -59,6 +59,13 @@ import { OrderInventory } from '../order-inventory/order-inventory'
   ],
   { unique: true }
 )
+@Index(
+  'ix_order-product_4',
+  (orderProduct: OrderProduct) => [
+    orderProduct.draftReleaseGood
+  ],
+  { unique: false }
+)
 @ObjectType()
 export class OrderProduct {
   @PrimaryGeneratedColumn('uuid')

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

@@ -1,7 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { OrderTote } from './order-tote'
 
@@ -9,20 +7,23 @@ import { OrderTote } from './order-tote'
 export class OrderToteMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderTote(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderTote(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
 
-    await tx.getRepository(OrderTote).delete({ domain, id })
+    await tx.getRepository(OrderTote).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderTotes(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
 
     await tx.getRepository(OrderTote).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
     return true

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

@@ -1,27 +1,25 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, In, IsNull } from 'typeorm'
+import { Arg, Ctx, Query, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
-import { ReleaseGood } from '../release-good/release-good'
+import { buildQuery, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
 import { Tote } from '@things-factory/warehouse-base'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
-import { Bizplace } from '@things-factory/biz-base'
 
+import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+import { ReleaseGood } from '../release-good/release-good'
 import { OrderTote } from './order-tote'
 import { OrderToteList } from './order-tote-types'
-import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
 
 @Resolver(OrderTote)
 export class OrderToteQuery {
   @Query(returns => OrderToteList)
   async orderTotes(
-    @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<OrderToteList> {
     try {
-      const { domain }: { domain: Domain } = context.state
+      const { domain } = context.state
 
       const releaseGoodNoParam = filters.find(item => item.name === 'releaseGoodNo')
 
@@ -65,11 +63,11 @@ export class OrderToteQuery {
   }
 
   @Query(returns => OrderTote)
-  async orderTote(@Arg('id') id: string, @Ctx() context: any): Promise<OrderTote> {
-    const { domain }: { domain: Domain } = context.state
+  async orderTote(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<OrderTote> {
+    const { domain } = context.state
 
     return await getRepository(OrderTote).findOne({
-      where: { domain, id },
+      where: { domain: { id: domain.id }, id },
       relations: ['domain', 'releaseGood', 'tote', 'updater']
     })
   }
@@ -78,9 +76,9 @@ export class OrderToteQuery {
   async checkOrderTote(
     @Arg('name') name: string,
     @Arg('orderNo') orderNo: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Boolean> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
     let foundOrder = await getRepository(ReleaseGood).findOne({
       where: { name: orderNo, domain },
       relations: ['bizplace']
@@ -88,7 +86,7 @@ export class OrderToteQuery {
     let scannedTote = await getRepository(Tote).findOne({ where: { name, bizplace: foundOrder.bizplace } })
 
     let foundOrderTote = await getRepository(OrderTote).findOne({
-      where: { domain, releaseGood: foundOrder, name },
+      where: { domain: { id: domain.id }, releaseGood: { id: foundOrder.id }, name },
       relations: ['domain', 'releaseGood', 'tote', 'updater']
     })
 

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

@@ -1,11 +1,21 @@
 import { Field, ObjectType } from 'type-graphql'
-import { Column, Entity, Index, ManyToOne, PrimaryGeneratedColumn, RelationId, UpdateDateColumn } from 'typeorm'
+import {
+  Column,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Domain } from '@things-factory/shell'
 import { Tote } from '@things-factory/warehouse-base'
-import { ReleaseGood } from '../release-good/release-good'
+
 import { OrderToteSeal } from '../order-tote-seal/order-tote-seal'
+import { ReleaseGood } from '../release-good/release-good'
 
 @Entity()
 @Index('ix_order_tote_0', (orderTote: OrderTote) => [orderTote.id], { unique: true })
@@ -57,6 +67,7 @@ export class OrderTote {
   @RelationId((orderTote: OrderTote) => orderTote.updater)
   updaterId: string
 
+  @OneToMany(type => OrderToteSeal, orderToteSeal => orderToteSeal.orderTote, { nullable: true })
   @Field(type => [OrderToteSeal], { nullable: true })
   orderToteSeals?: OrderToteSeal[]
 }

package/server/service/order-tote-item/order-tote-item-mutation.ts

@@ -1,7 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { OrderToteItem } from './order-tote-item'
 
@@ -9,20 +7,23 @@ import { OrderToteItem } from './order-tote-item'
 export class OrderToteItemMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderToteItem(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderToteItem(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
 
-    await tx.getRepository(OrderToteItem).delete({ domain, id })
+    await tx.getRepository(OrderToteItem).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderToteItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderToteItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
 
     await tx.getRepository(OrderToteItem).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
     return true

package/server/service/order-tote-item/order-tote-item-query.ts

@@ -1,31 +1,25 @@
-import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+import { Arg, Ctx, Query, Resolver } from 'type-graphql'
 
-import { User } from '@things-factory/auth-base'
-import { OrderProduct } from '../order-product/order-product'
-import { OrderTote } from '../order-tote/order-tote'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { buildQuery, getRepository, Sorting } from '@things-factory/shell'
+
+import { ReleaseGood } from '../release-good/release-good'
 import { OrderToteItem } from './order-tote-item'
 import { OrderToteItemList } from './order-tote-item-types'
-import { Tote } from '@things-factory/warehouse-base'
-import { Bizplace } from '@things-factory/biz-base'
-import { ReleaseGood } from '../release-good/release-good'
-import { ProductInput } from '../invoice-product/invoice-product-types'
 
 @Resolver(OrderToteItem)
 export class OrderToteItemQuery {
   @Query(returns => OrderToteItemList)
   async orderToteItems(
-    @Ctx() context: any,
-    @Arg('toteNo', type => String) toteNo: String,
-    @Arg('orderNo', type => String) orderNo: String,
+    @Ctx() context: ResolverContext,
+    @Arg('toteNo', type => String) toteNo: string,
+    @Arg('orderNo', type => String) orderNo: string,
     @Arg('sortings', type => [Sorting], { nullable: true }) sortings?: Sorting[]
   ): Promise<OrderToteItemList> {
     try {
-      const { domain }: { domain: Domain } = context.state
+      const { domain } = context.state
 
       const foundOrder: ReleaseGood = await getRepository(ReleaseGood).findOne({
-        where: { name: orderNo, domain }
+        where: { domain: { id: domain.id }, name: orderNo }
       })
 
       const queryBuilder = getRepository(OrderToteItem).createQueryBuilder()
@@ -77,11 +71,11 @@ export class OrderToteItemQuery {
   }
 
   @Query(returns => OrderToteItem)
-  async orderToteItem(@Arg('id') id: string, @Ctx() context: any): Promise<OrderToteItem> {
-    const { domain }: { domain: Domain } = context.state
+  async orderToteItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<OrderToteItem> {
+    const { domain } = context.state
 
     return await getRepository(OrderToteItem).findOne({
-      where: { domain, id },
+      where: { domain: { id: domain.id }, id },
       relations: ['domain', 'orderProduct', 'orderInventory', 'orderTote', 'updater']
     })
   }

package/server/service/order-tote-seal/order-tote-seal-mutation.ts

@@ -1,7 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { OrderToteSeal } from './order-tote-seal'
 
@@ -9,20 +7,23 @@ import { OrderToteSeal } from './order-tote-seal'
 export class OrderToteSealMutation {
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderToteSeal(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderToteSeal(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, tx } = context.state
 
-    await tx.getRepository(OrderToteSeal).delete({ domain, id })
+    await tx.getRepository(OrderToteSeal).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteOrderToteSeals(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async deleteOrderToteSeals(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, tx } = context.state
 
     await tx.getRepository(OrderToteSeal).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
     return true

package/server/service/order-tote-seal/order-tote-seal-query.ts

@@ -1,10 +1,9 @@
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { OrderTote } from '../order-tote/order-tote'
-import { buildQuery, Domain, Filter, Pagination, Sorting } from '@things-factory/shell'
+import { buildQuery, Domain, Filter, getRepository, Pagination, Sorting } from '@things-factory/shell'
 
+import { OrderTote } from '../order-tote/order-tote'
 import { OrderToteSeal } from './order-tote-seal'
 import { OrderToteSealList } from './order-tote-seal-types'
 
@@ -12,12 +11,12 @@ import { OrderToteSealList } from './order-tote-seal-types'
 export class OrderToteSealQuery {
   @Query(returns => OrderToteSealList)
   async orderToteSeals(
-    @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<OrderToteSealList> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
 
     const queryBuilder = getRepository(OrderToteSeal).createQueryBuilder()
     buildQuery(queryBuilder, { filters, pagination, sortings }, context)
@@ -34,27 +33,27 @@ export class OrderToteSealQuery {
   }
 
   @Query(returns => OrderToteSeal)
-  async orderToteSeal(@Arg('name') name: string, @Ctx() context: any): Promise<OrderToteSeal> {
-    const { domain }: { domain: Domain } = context.state
+  async orderToteSeal(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<OrderToteSeal> {
+    const { domain } = context.state
 
     return await getRepository(OrderToteSeal).findOne({
-      where: { domain, name },
+      where: { domain: { id: domain.id }, name },
       relations: ['domain', 'orderTote', 'updater']
     })
   }
 
   @FieldResolver()
   async domain(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(Domain).findOne(orderToteSeal.domainId)
+    return await getRepository(Domain).findOneBy({ id: orderToteSeal.domainId })
   }
 
   @FieldResolver()
   async updater(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(User).findOne(orderToteSeal.updaterId)
+    return await getRepository(User).findOneBy({ id: orderToteSeal.updaterId })
   }
 
   @FieldResolver()
   async orderTote(@Root() orderToteSeal: OrderToteSeal) {
-    return await getRepository(OrderTote).findOne(orderToteSeal.orderToteId)
+    return await getRepository(OrderTote).findOneBy({ id: orderToteSeal.orderToteId })
   }
 }

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

@@ -1,6 +1,5 @@
-import { Domain } from '@things-factory/shell'
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager } from 'typeorm'
+
 import { OrderVasPatch } from '../'
 import { OrderVas } from './order-vas'
 
@@ -11,11 +10,11 @@ export class OrderVasMutation {
   async updateOrderVas(
     @Arg('id') id: string,
     @Arg('patch', type => OrderVasPatch) patch: OrderVasPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<OrderVas> {
-    const { tx, domain }: { tx: EntityManager; domain: Domain } = context.state
+    const { tx, domain } = context.state
 
-    let orderVas = await tx.getRepository(OrderVas).findOne(id)
+    let orderVas = await tx.getRepository(OrderVas).findOneBy({ id })
     return await tx.getRepository(OrderVas).save({ orderVas, ...patch })
   }
 }

package/server/service/order-vas/order-vas-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 { OrderVasList } from '../'
 import { OrderVas } from './order-vas'
 
@@ -32,12 +33,12 @@ export class OrderVasQuery {
   }
 
   @Query(returns => OrderVas)
-  async orderVas(@Arg('name') name: string, @Ctx() context: any): Promise<OrderVas> {
-    const { domain }: { domain: Domain } = context.state
+  async orderVas(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<OrderVas> {
+    const { domain } = context.state
 
     return await getRepository(OrderVas).findOne({
       where: {
-        domain,
+        domain: { id: domain.id },
         name
       },
       relations: [
@@ -56,16 +57,16 @@ export class OrderVasQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() orderVas: OrderVas): Promise<Domain> {
-    return await getRepository(Domain).findOne(orderVas.domainId)
+    return await getRepository(Domain).findOneBy({ id: orderVas.domainId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() orderVas: OrderVas): Promise<User> {
-    return await getRepository(User).findOne(orderVas.creatorId)
+    return await getRepository(User).findOneBy({ id: orderVas.creatorId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() orderVas: OrderVas): Promise<User> {
-    return await getRepository(User).findOne(orderVas.updaterId)
+    return await getRepository(User).findOneBy({ id: orderVas.updaterId })
   }
 }