@things-factory/warehouse-base 5.0.14 → 6.0.0-alpha.0

package/server/service/inventory-item/inventory-item-mutation.ts

@@ -14,7 +14,7 @@ export class InventoryItemMutation {
   @Mutation(returns => InventoryItem, { description: 'To create new InventoryItem' })
   async createInventoryItem(
     @Arg('inventoryItem') inventoryItem: NewInventoryItem,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItem> {
     const { domain, user, tx } = context.state
 
@@ -31,13 +31,13 @@ export class InventoryItemMutation {
   async updateInventoryItem(
     @Arg('id') id: string,
     @Arg('patch') patch: InventoryItemPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItem> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(InventoryItem)
     const inventoryItem = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -52,7 +52,7 @@ export class InventoryItemMutation {
   async updateInventoryItemSerialNumber(
     @Arg('id') id: string,
     @Arg('serialNumber') serialNumber: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     try {
       const { domain, user, tx } = context.state
@@ -60,14 +60,14 @@ export class InventoryItemMutation {
       const repository = tx.getRepository(InventoryItem)
 
       const inventoryItem = await repository.findOne({
-        where: { domain, id },
+        where: { domain: { id: domain.id }, id },
         relations: ['product']
       })
 
       const product: Product = inventoryItem.product
-      const duplicatedSerialNumberCnt: number = await repository.count({
-        domain,
-        product,
+      const duplicatedSerialNumberCnt: number = await repository.countBy({
+        domain: { id: domain.id },
+        product: { id: product.id },
         serialNumber
       })
 
@@ -85,7 +85,7 @@ export class InventoryItemMutation {
   @Mutation(returns => [InventoryItem], { description: "To modify multiple InventoryItems' information" })
   async updateMultipleInventoryItem(
     @Arg('patches', type => [InventoryItemPatch]) patches: InventoryItemPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItem[]> {
     const { domain, user, tx } = context.state
 
@@ -112,7 +112,7 @@ export class InventoryItemMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const inventoryItem = await inventoryItemRepo.findOne(newRecord.id)
+        const inventoryItem = await inventoryItemRepo.findOneBy({ id: newRecord.id })
 
         const result = await inventoryItemRepo.save({
           ...inventoryItem,
@@ -129,21 +129,24 @@ export class InventoryItemMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete InventoryItem' })
-  async deleteInventoryItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteInventoryItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(InventoryItem).delete({ domain, id })
+    await tx.getRepository(InventoryItem).delete({ domain: { id: domain.id }, id })
 
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItems' })
-  async deleteInventoryItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteInventoryItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(InventoryItem).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -155,13 +158,13 @@ export class InventoryItemMutation {
   async replacePickedInventoryItem(
     @Arg('selectedSerialNumber') selectedSerialNumber: InventoryItemPatch,
     @Arg('newSerialNumber') newSerialNumber: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItem> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(InventoryItem)
     const foundSerialNumber = await repository.findOne({
-      where: { domain, serialNumber: newSerialNumber }
+      where: { domain: { id: domain.id }, serialNumber: newSerialNumber }
     })
 
     if ((selectedSerialNumber.source = INVENTORY_ITEM_SOURCE.OUTBOUND)) {
@@ -169,7 +172,7 @@ export class InventoryItemMutation {
     } else {
       await repository.update(
         {
-          domain,
+          domain: { id: domain.id },
           id: selectedSerialNumber.id
         },
         {

package/server/service/inventory-item/inventory-item-query.ts

@@ -1,9 +1,9 @@
 import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { Brackets, EntityManager, getRepository, In, Not, SelectQueryBuilder } from 'typeorm'
+import { Brackets, EntityManager, In, Not, OrderByCondition, SelectQueryBuilder } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Product } from '@things-factory/product-base'
-import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+import { convertListParams, Domain, getRepository, ListParam } from '@things-factory/shell'
 
 import { INVENTORY_STATUS } from '../../constants'
 import { Inventory } from '../inventory/inventory'
@@ -13,16 +13,16 @@ import { InventoryItemList } from './inventory-item-type'
 @Resolver(InventoryItem)
 export class InventoryItemQuery {
   @Query(returns => InventoryItem, { description: 'To fetch a InventoryItem' })
-  async inventoryItem(@Arg('id') id: string, @Ctx() context: any): Promise<InventoryItem> {
+  async inventoryItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InventoryItem> {
     const { domain } = context.state
 
     return await getRepository(InventoryItem).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems' })
-  async inventoryItems(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
+  async inventoryItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<InventoryItemList> {
     const { domain } = context.state
 
     const convertedParams = convertListParams(params, { domain })
@@ -36,8 +36,11 @@ export class InventoryItemQuery {
 
   @Directive('@transaction')
   @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems with InventoryItemChanges' })
-  async inventoryItemsWithChanges(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+  async inventoryItemsWithChanges(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryItemList> {
+    const { domain, tx } = context.state
 
     const page = params?.pagination?.page
     const limit = params?.pagination?.limit
@@ -102,7 +105,10 @@ export class InventoryItemQuery {
   }
 
   @Query(returns => InventoryItemList, { description: 'To fetch multiple InventoryItems by inventory' })
-  async inventoryItemsByInventory(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemList> {
+  async inventoryItemsByInventory(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryItemList> {
     const { domain } = context.state
 
     const page = params.pagination.page
@@ -153,7 +159,7 @@ export class InventoryItemQuery {
 
     if (sortings?.length !== 0) {
       const arrChildSortData = ['serial_number']
-      const sort = (sortings || []).reduce(
+      const sort: OrderByCondition = (sortings || []).reduce(
         (acc, sort) => ({
           ...acc,
           [arrChildSortData.indexOf(sort.name) >= 0 ? sort.name + '.name' : 'ivi.' + sort.name]: sort.desc
@@ -175,17 +181,17 @@ export class InventoryItemQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() inventoryItem: InventoryItem): Promise<Domain> {
-    return await getRepository(Domain).findOne(inventoryItem.domainId)
+    return await getRepository(Domain).findOneBy({ id: inventoryItem.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() inventoryItem: InventoryItem): Promise<User> {
-    return await getRepository(User).findOne(inventoryItem.updaterId)
+    return await getRepository(User).findOneBy({ id: inventoryItem.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() inventoryItem: InventoryItem): Promise<User> {
-    return await getRepository(User).findOne(inventoryItem.creatorId)
+    return await getRepository(User).findOneBy({ id: inventoryItem.creatorId })
   }
 }
 
@@ -196,18 +202,22 @@ export async function checkExistingSerialNumber(
   inventory?: Inventory,
   tx?: EntityManager
 ) {
-  const { domain }: { domain: Domain } = context.state
+  const { domain } = context.state
 
   let countCondition: any = {
-    domain,
-    product,
+    domain: { id: domain.id },
+    product: { id: product.id },
     serialNumber,
     status: Not(In([INVENTORY_STATUS.DELETED, INVENTORY_STATUS.TERMINATED]))
   }
 
-  if (inventory) countCondition = { ...countCondition, inventory }
+  if (inventory) {
+    countCondition = { ...countCondition, inventory: { id: inventory.id } }
+  }
 
-  const duplicatedSerialNumberCnt: number = await tx.getRepository(InventoryItem).count(countCondition)
+  const duplicatedSerialNumberCnt: number = await tx.getRepository(InventoryItem).countBy(countCondition)
 
-  if (duplicatedSerialNumberCnt) return true
+  if (duplicatedSerialNumberCnt) {
+    return true
+  }
 }

package/server/service/inventory-item-change/inventory-item-change-mutation.ts

@@ -11,7 +11,7 @@ export class InventoryItemChangeMutation {
   @Mutation(returns => InventoryItemChange, { description: 'To create new InventoryItemChange' })
   async createInventoryItemChange(
     @Arg('inventoryItemChange') inventoryItemChange: NewInventoryItemChange,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItemChange> {
     const { domain, user, tx } = context.state
 
@@ -30,13 +30,13 @@ export class InventoryItemChangeMutation {
   async updateInventoryItemChange(
     @Arg('id') id: string,
     @Arg('patch') patch: InventoryItemChangePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItemChange> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(InventoryItemChange)
     const inventoryItemChange = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -50,7 +50,7 @@ export class InventoryItemChangeMutation {
   @Mutation(returns => [InventoryItemChange], { description: "To modify multiple InventoryItemChanges' information" })
   async updateMultipleInventoryItemChange(
     @Arg('patches', type => [InventoryItemChangePatch]) patches: InventoryItemChangePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryItemChange[]> {
     const { domain, user, tx } = context.state
 
@@ -77,7 +77,7 @@ export class InventoryItemChangeMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const inventoryItemChange = await inventoryItemChangeRepo.findOne(newRecord.id)
+        const inventoryItemChange = await inventoryItemChangeRepo.findOneBy({ id: newRecord.id })
 
         const result = await inventoryItemChangeRepo.save({
           ...inventoryItemChange,
@@ -94,20 +94,23 @@ export class InventoryItemChangeMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete InventoryItemChange' })
-  async deleteInventoryItemChange(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteInventoryItemChange(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(InventoryItemChange).delete({ domain, id })
+    await tx.getRepository(InventoryItemChange).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple inventoryItemChanges' })
-  async deleteInventoryItemChanges(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteInventoryItemChanges(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(InventoryItemChange).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

package/server/service/inventory-item-change/inventory-item-change-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 { InventoryItemChange } from './inventory-item-change'
 import { InventoryItemChangeList } from './inventory-item-change-type'
@@ -10,16 +9,19 @@ import { InventoryItemChangeList } from './inventory-item-change-type'
 @Resolver(InventoryItemChange)
 export class InventoryItemChangeQuery {
   @Query(returns => InventoryItemChange, { description: 'To fetch a InventoryItemChange' })
-  async inventoryItemChange(@Arg('id') id: string, @Ctx() context: any): Promise<InventoryItemChange> {
+  async inventoryItemChange(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InventoryItemChange> {
     const { domain } = context.state
 
     return await getRepository(InventoryItemChange).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => InventoryItemChangeList, { description: 'To fetch multiple InventoryItemChanges' })
-  async inventoryItemChanges(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryItemChangeList> {
+  async inventoryItemChanges(
+    @Args() params: ListParam,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryItemChangeList> {
     const { domain } = context.state
 
     const convertedParams = convertListParams(params, { domain })
@@ -30,16 +32,16 @@ export class InventoryItemChangeQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() inventoryItemChange: InventoryItemChange): Promise<Domain> {
-    return await getRepository(Domain).findOne(inventoryItemChange.domainId)
+    return await getRepository(Domain).findOneBy({ id: inventoryItemChange.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
-    return await getRepository(User).findOne(inventoryItemChange.updaterId)
+    return await getRepository(User).findOneBy({ id: inventoryItemChange.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() inventoryItemChange: InventoryItemChange): Promise<User> {
-    return await getRepository(User).findOne(inventoryItemChange.creatorId)
+    return await getRepository(User).findOneBy({ id: inventoryItemChange.creatorId })
   }
 }

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

@@ -1,13 +1,17 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
 import { InventoryProduct } from './inventory-product'
-import { NewInventoryProduct, InventoryProductPatch } from './inventory-product-type'
+import { InventoryProductPatch, NewInventoryProduct } from './inventory-product-type'
 
 @Resolver(InventoryProduct)
 export class InventoryProductMutation {
   @Directive('@transaction')
   @Mutation(returns => InventoryProduct, { description: 'To create new InventoryProduct' })
-  async createInventoryProduct(@Arg('inventoryProduct') inventoryProduct: NewInventoryProduct, @Ctx() context: any): Promise<InventoryProduct> {
+  async createInventoryProduct(
+    @Arg('inventoryProduct') inventoryProduct: NewInventoryProduct,
+    @Ctx() context: ResolverContext
+  ): Promise<InventoryProduct> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(InventoryProduct).save({
@@ -23,13 +27,13 @@ export class InventoryProductMutation {
   async updateInventoryProduct(
     @Arg('id') id: string,
     @Arg('patch') patch: InventoryProductPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryProduct> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(InventoryProduct)
     const inventoryProduct = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -43,7 +47,7 @@ export class InventoryProductMutation {
   @Mutation(returns => [InventoryProduct], { description: "To modify multiple InventoryProducts' information" })
   async updateMultipleInventoryProduct(
     @Arg('patches', type => [InventoryProductPatch]) patches: InventoryProductPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<InventoryProduct[]> {
     const { domain, user, tx } = context.state
 
@@ -70,7 +74,7 @@ export class InventoryProductMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const inventoryProduct = await inventoryProductRepo.findOne(newRecord.id)
+        const inventoryProduct = await inventoryProductRepo.findOneBy({ id: newRecord.id })
 
         const result = await inventoryProductRepo.save({
           ...inventoryProduct,
@@ -87,10 +91,10 @@ export class InventoryProductMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete InventoryProduct' })
-  async deleteInventoryProduct(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteInventoryProduct(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(InventoryProduct).delete({ domain, id })
+    await tx.getRepository(InventoryProduct).delete({ domain: { id: domain.id }, id })
     return true
   }
 
@@ -98,12 +102,12 @@ export class InventoryProductMutation {
   @Mutation(returns => Boolean, { description: 'To delete multiple inventoryProducts' })
   async deleteInventoryProducts(
     @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(InventoryProduct).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

package/server/service/inventory-product/inventory-product-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 { InventoryProduct } from './inventory-product'
 import { InventoryProductList } from './inventory-product-type'
@@ -10,16 +9,16 @@ import { InventoryProductList } from './inventory-product-type'
 @Resolver(InventoryProduct)
 export class InventoryProductQuery {
   @Query(returns => InventoryProduct, { description: 'To fetch a InventoryProduct' })
-  async inventoryProduct(@Arg('id') id: string, @Ctx() context: any): Promise<InventoryProduct> {
+  async inventoryProduct(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<InventoryProduct> {
     const { domain } = context.state
 
     return await getRepository(InventoryProduct).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => InventoryProductList, { description: 'To fetch multiple InventoryProducts' })
-  async inventoryProducts(@Args() params: ListParam, @Ctx() context: any): Promise<InventoryProductList> {
+  async inventoryProducts(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<InventoryProductList> {
     const { domain } = context.state
 
     const convertedParams = convertListParams(params, { domain })
@@ -30,16 +29,16 @@ export class InventoryProductQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() inventoryProduct: InventoryProduct): Promise<Domain> {
-    return await getRepository(Domain).findOne(inventoryProduct.domainId)
+    return await getRepository(Domain).findOneBy({ id: inventoryProduct.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() inventoryProduct: InventoryProduct): Promise<User> {
-    return await getRepository(User).findOne(inventoryProduct.updaterId)
+    return await getRepository(User).findOneBy({ id: inventoryProduct.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() inventoryProduct: InventoryProduct): Promise<User> {
-    return await getRepository(User).findOne(inventoryProduct.creatorId)
+    return await getRepository(User).findOneBy({ id: inventoryProduct.creatorId })
   }
 }

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

@@ -1,8 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { Repository } from 'typeorm'
 
 import { Location } from '../location/location'
 import { Warehouse } from '../warehouse/warehouse'
@@ -13,7 +10,7 @@ export class LocationMutation {
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Location)
-  async createLocation(@Arg('location') location: NewLocation, @Ctx() context: any): Promise<Location> {
+  async createLocation(@Arg('location') location: NewLocation, @Ctx() context: ResolverContext): Promise<Location> {
     return await createLocation(location, context)
   }
 
@@ -23,9 +20,9 @@ export class LocationMutation {
   async updateLocation(
     @Arg('id') id: string,
     @Arg('patch') patch: LocationPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Location> {
-    return await updateLocation(id, patch, context.state.user)
+    return await updateLocation(id, patch, context)
   }
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
@@ -33,7 +30,7 @@ export class LocationMutation {
   @Mutation(returns => [Location])
   async updateMultipleLocation(
     @Arg('patches', type => [LocationPatch]) patches: LocationPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Location[]> {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
@@ -61,53 +58,56 @@ export class LocationMutation {
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteLocation(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+  async deleteLocation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
     return await deleteLocation(id, context)
   }
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteLocations(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+  async deleteLocations(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
     return await deleteLocations(ids, context)
   }
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteAllLocations(@Arg('warehouseId') warehouseId: string, @Ctx() context: any) {
-    const { tx }: { tx: EntityManager } = context.state
+  async deleteAllLocations(@Arg('warehouseId') warehouseId: string, @Ctx() context: ResolverContext) {
+    const { tx } = context.state
 
     await tx.getRepository(Location).delete({
-      warehouse: await tx.getRepository(Warehouse).findOne(warehouseId)
+      warehouse: { id: warehouseId }
     })
   }
 }
 
-export async function createLocation(location: NewLocation, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+export async function createLocation(location: NewLocation, context: ResolverContext) {
+  const { domain, user, tx } = context.state
 
   const locationRepository: Repository<Location> = tx.getRepository(Location)
   const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
 
   return await locationRepository.save({
     ...location,
-    warehouse: await warehouseRepository.findOne(location.warehouse.id),
+    warehouse: await warehouseRepository.findOneBy({ id: location.warehouse.id }),
     domain,
     creator: user,
     updater: user
   })
 }
 
-export async function updateLocation(id: string, patch: LocationPatch, context: any) {
-  const { user, tx }: { user: User; tx: EntityManager } = context.state
+export async function updateLocation(id: string, patch: LocationPatch, context: ResolverContext) {
+  const { user, tx } = context.state
 
   const locationRepository: Repository<Location> = tx.getRepository(Location)
   const warehouseRepository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  const location: Location = await locationRepository.findOne(id)
+  const location: Location = await locationRepository.findOneBy({ id })
 
   if (patch.warehouse && patch.warehouse.id) {
-    patch.warehouse = await warehouseRepository.findOne(patch.warehouse.id)
+    patch.warehouse = await warehouseRepository.findOneBy({ id: patch.warehouse.id })
   }
 
   return await locationRepository.save({
@@ -117,16 +117,16 @@ export async function updateLocation(id: string, patch: LocationPatch, context:
   })
 }
 
-export async function deleteLocation(id: string, context: any) {
-  const { tx }: { tx: EntityManager } = context.state
+export async function deleteLocation(id: string, context: ResolverContext) {
+  const { tx } = context.state
 
   const repository: Repository<Location> = tx.getRepository(Location)
   await repository.delete(id)
   return true
 }
 
-export async function deleteLocations(ids: string[], context: any) {
-  const { tx }: { tx: EntityManager } = context.state
+export async function deleteLocations(ids: string[], context: ResolverContext) {
+  const { tx } = context.state
 
   const repository: Repository<Location> = tx.getRepository(Location)
   await repository.delete(ids)