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

package/server/service/pallet-history/pallet-history-mutation.ts

@@ -1,8 +1,5 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
+import { In } from 'typeorm'
 
 import { PalletHistory } from './pallet-history'
 import { NewPalletHistory, PalletHistoryPatch } from './pallet-history-types'
@@ -13,9 +10,9 @@ export class PalletHistoryMutation {
   @Mutation(returns => PalletHistory)
   async createPalletHistory(
     @Arg('palletHistory') palletHistory: NewPalletHistory,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<PalletHistory> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
 
     return await tx.getRepository(PalletHistory).save({
       ...palletHistory,
@@ -30,9 +27,9 @@ export class PalletHistoryMutation {
   async updatePalletHistory(
     @Arg('name') name: string,
     @Arg('patch') patch: PalletHistoryPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<PalletHistory> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(PalletHistory)
     const palletHistory = await repository.findOne({
@@ -50,9 +47,9 @@ export class PalletHistoryMutation {
   @Mutation(returns => [PalletHistory])
   async updateMultiplePalletHistory(
     @Arg('patches', type => [PalletHistoryPatch]) patches: PalletHistoryPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<PalletHistory[]> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
@@ -76,7 +73,7 @@ export class PalletHistoryMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const palletHistory = await palletHistoryRepo.findOne(newRecord.id)
+        const palletHistory = await palletHistoryRepo.findOneBy({ id: newRecord.id })
 
         const result = await palletHistoryRepo.save({
           ...palletHistory,
@@ -93,8 +90,8 @@ export class PalletHistoryMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deletePalletHistory(@Arg('name') name: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async deletePalletHistory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, user, tx } = context.state
 
     await tx.getRepository(PalletHistory).delete({ domain: domain, name })
     return true
@@ -102,8 +99,11 @@ export class PalletHistoryMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deletePalletHistories(@Arg('names', type => [String]) names: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async deletePalletHistories(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
+    const { domain, user, tx } = context.state
 
     await tx.getRepository(PalletHistory).delete({
       domain: domain,

package/server/service/pallet-history/pallet-history-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 { PalletHistory } from './pallet-history'
 import { PalletHistoryList } from './pallet-history-types'
@@ -10,7 +9,7 @@ import { PalletHistoryList } from './pallet-history-types'
 @Resolver(PalletHistory)
 export class PalletHistoryQuery {
   @Query(returns => PalletHistoryList)
-  async palletHistories(@Args() params: ListParam, @Ctx() context: any): Promise<PalletHistoryList> {
+  async palletHistories(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<PalletHistoryList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(PalletHistory).findAndCount({
       ...convertedParams,
@@ -20,8 +19,8 @@ export class PalletHistoryQuery {
   }
 
   @Query(returns => PalletHistory)
-  async palletHistory(@Arg('name') name: string, @Ctx() context: any): Promise<PalletHistory> {
-    const { domain }: { domain: Domain } = context.state
+  async palletHistory(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<PalletHistory> {
+    const { domain } = context.state
 
     return await getRepository(PalletHistory).findOne({
       where: { domain: domain, name },
@@ -31,16 +30,16 @@ export class PalletHistoryQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() palletHistory: PalletHistory) {
-    return await getRepository(Domain).findOne(palletHistory.domainId)
+    return await getRepository(Domain).findOneBy({ id: palletHistory.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() palletHistory: PalletHistory) {
-    return await getRepository(User).findOne(palletHistory.updaterId)
+    return await getRepository(User).findOneBy({ id: palletHistory.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() palletHistory: PalletHistory) {
-    return await getRepository(User).findOne(palletHistory.creatorId)
+    return await getRepository(User).findOneBy({ id: palletHistory.creatorId })
   }
 }

package/server/service/reduced-inventory-history/reduced-inventory-history.ts

@@ -9,7 +9,7 @@ import { ViewColumn, ViewEntity } from 'typeorm'
     AND (
       ((ih2.transaction_type::text = 'CANCEL_ORDER'::text) AND ih2.ref_order_id::text = ih.ref_order_id::TEXT) 
       OR
-      ((ih2.seq = (ih.seq + 1) OR ih2.seq = ih.seq) AND (ih2.transaction_type::text = 'UNDO_UNLOADING'::TEXT OR ih2.transaction_type::text = 'UNDO_LOADING'::TEXT))
+      ((ih2.seq = (ih.seq + 1) OR ih2.seq = ih.seq) AND (ih2.transaction_type::text = 'UNDO_UNLOADING'::TEXT))
     )
   )
   `

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

@@ -1,11 +1,8 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, In } from 'typeorm'
+import { In } from 'typeorm'
 
-import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
 
-import { PalletHistory } from '../pallet-history/pallet-history'
 import { Tote } from './tote'
 import { NewTote, TotePatch } from './tote-types'
 
@@ -13,8 +10,8 @@ import { NewTote, TotePatch } from './tote-types'
 export class ToteMutation {
   @Directive('@transaction')
   @Mutation(returns => Tote)
-  async createTote(@Arg('pallet') tote: NewTote, @Ctx() context: any): Promise<Tote> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async createTote(@Arg('pallet') tote: NewTote, @Ctx() context: ResolverContext): Promise<Tote> {
+    const { domain, user, tx } = context.state
 
     const existingTote: string[] = (await tx.getRepository(Tote).find({ relations: ['user'] })).map(tote => tote.name)
     if (existingTote.includes(tote.name)) throw new Error('tote box already exists')
@@ -29,8 +26,12 @@ export class ToteMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Tote)
-  async updateTote(@Arg('name') name: string, @Arg('patch') patch: TotePatch, @Ctx() context: any): Promise<Tote> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async updateTote(
+    @Arg('name') name: string,
+    @Arg('patch') patch: TotePatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Tote> {
+    const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Tote)
     const tote = await repository.findOne({
@@ -48,9 +49,9 @@ export class ToteMutation {
   @Mutation(returns => [Tote])
   async updateMultipleTote(
     @Arg('patches', type => [TotePatch]) patches: TotePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Tote[]> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+    const { domain, user, tx } = context.state
 
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
@@ -61,12 +62,12 @@ export class ToteMutation {
         const newRecord = _createRecords[i]
 
         if (newRecord.bizplace && newRecord.bizplace.id) {
-          newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
+          newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
         }
 
         let foundTote = await tx
           .getRepository(Tote)
-          .findOne({ where: { domain, name: newRecord.name, bizplace: newRecord.bizplace } })
+          .findOne({ where: { domain: { id: domain.id }, name: newRecord.name, bizplace: newRecord.bizplace } })
 
         if (foundTote) {
           throw new Error('Duplicated tote found')
@@ -92,12 +93,12 @@ export class ToteMutation {
         })
 
         if (newRecord.bizplace && newRecord.bizplace.id) {
-          newRecord.bizplace = await tx.getRepository(Bizplace).findOne(newRecord.bizplace.id)
+          newRecord.bizplace = (await tx.getRepository(Bizplace).findOneBy({ id: newRecord.bizplace.id })) as any
         }
 
         let foundTote = await tx
           .getRepository(Tote)
-          .findOne({ where: { domain, name: newRecord.name, bizplace: newRecord.bizplace } })
+          .findOne({ where: { domain: { id: domain.id }, name: newRecord.name, bizplace: newRecord.bizplace } })
 
         if (foundTote) {
           throw new Error('Duplicated tote found')
@@ -118,8 +119,8 @@ export class ToteMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteTote(@Arg('name') id: string, @Ctx() context: any): Promise<Boolean> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async deleteTote(@Arg('name') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, user, tx } = context.state
 
     const foundTote = await tx.getRepository(Tote).find({ where: { id } })
 
@@ -133,8 +134,8 @@ export class ToteMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async deleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { domain, user, tx } = context.state
 
     const totes = await tx.getRepository(Tote).find({
       where: {
@@ -158,8 +159,8 @@ export class ToteMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async undeleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
-    const { tx, user }: { tx: EntityManager; user: User } = context.state
+  async undeleteTotes(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<Boolean> {
+    const { tx, user } = context.state
     const toteRepo = tx.getRepository(Tote)
 
     await toteRepo.update(
@@ -180,9 +181,9 @@ export class ToteMutation {
   async bulkUpdateToteStatus(
     @Arg('ids', type => [String]) ids: string[],
     @Arg('status', type => String) status: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Boolean> {
-    const { tx, user }: { tx: EntityManager; user: User } = context.state
+    const { tx, user } = context.state
     const toteRepo = tx.getRepository(Tote)
 
     await toteRepo.update(

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

@@ -1,9 +1,9 @@
 import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository, IsNull } from 'typeorm'
+import { IsNull } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } 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 { Tote } from './tote'
 import { ToteList } from './tote-types'
@@ -12,12 +12,12 @@ import { ToteList } from './tote-types'
 export class ToteQuery {
   @Query(returns => ToteList)
   async totes(
-    @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<ToteList> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
 
     const deletedFilter: any = filters.find((filter: any) => filter.name === 'deleted' && filter.value === true)
 
@@ -43,12 +43,16 @@ export class ToteQuery {
   }
 
   @Query(returns => Tote)
-  async tote(@Arg('name') name: string, @Arg('bizplace') bizplace: string, @Ctx() context: any): Promise<Tote> {
-    const { domain }: { domain: Domain } = context.state
+  async tote(
+    @Arg('name') name: string,
+    @Arg('bizplace') bizplace: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Tote> {
+    const { domain } = context.state
     let foundBizplace = await getRepository(Bizplace).findOne({ where: { name: bizplace } })
 
     let foundTote = await getRepository(Tote).findOne({
-      where: { domain, bizplace: foundBizplace, name, deletedAt: IsNull() },
+      where: { domain: { id: domain.id }, bizplace: foundBizplace, name, deletedAt: IsNull() },
       relations: ['domain', 'bizplace', 'creator', 'updater']
     })
 
@@ -63,13 +67,13 @@ export class ToteQuery {
   async checkToteStatus(
     @Arg('name') name: string,
     @Arg('bizplace') bizplace: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<String> {
-    const { domain }: { domain: Domain } = context.state
+    const { domain } = context.state
     let foundBizplace = await getRepository(Bizplace).findOne({ where: { name: bizplace } })
 
     let foundTote = await getRepository(Tote).findOne({
-      where: { domain, bizplace: foundBizplace, name, deletedAt: IsNull() },
+      where: { domain: { id: domain.id }, bizplace: foundBizplace, name, deletedAt: IsNull() },
       relations: ['domain', 'bizplace', 'creator', 'updater']
     })
 
@@ -82,21 +86,21 @@ export class ToteQuery {
 
   @FieldResolver()
   async domain(@Root() tote: Tote) {
-    return await getRepository(Domain).findOne(tote.domainId)
+    return await getRepository(Domain).findOneBy({ id: tote.domainId })
   }
 
   @FieldResolver()
   async bizplace(@Root() tote: Tote) {
-    return await getRepository(Bizplace).findOne(tote.bizplaceId)
+    return await getRepository(Bizplace).findOneBy({ id: tote.bizplaceId })
   }
 
   @FieldResolver()
   async updater(@Root() tote: Tote) {
-    return await getRepository(User).findOne(tote.updaterId)
+    return await getRepository(User).findOneBy({ id: tote.updaterId })
   }
 
   @FieldResolver()
   async creator(@Root() tote: Tote) {
-    return await getRepository(User).findOne(tote.creatorId)
+    return await getRepository(User).findOneBy({ id: tote.creatorId })
   }
 }

package/server/service/warehouse/warehouse-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 { Warehouse } from './warehouse'
 import { NewWarehouse, WarehousePatch } from './warehouse-types'
@@ -12,7 +9,10 @@ export class WarehouseMutation {
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Warehouse)
-  async createWarehouse(@Arg('warehouse') warehouse: NewWarehouse, @Ctx() context: any): Promise<Warehouse> {
+  async createWarehouse(
+    @Arg('warehouse') warehouse: NewWarehouse,
+    @Ctx() context: ResolverContext
+  ): Promise<Warehouse> {
     return await createWarehouse(warehouse, context)
   }
 
@@ -22,7 +22,7 @@ export class WarehouseMutation {
   async updateWarehouse(
     @Arg('id') id: string,
     @Arg('patch') patch: WarehousePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Warehouse> {
     return await updateWarehouse(id, patch, context)
   }
@@ -32,7 +32,7 @@ export class WarehouseMutation {
   @Mutation(returns => [Warehouse])
   async updateMultipleWarehouse(
     @Arg('patches', type => [WarehousePatch]) patches: WarehousePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Warehouse[]> {
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
@@ -60,20 +60,23 @@ export class WarehouseMutation {
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteWarehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Boolean> {
+  async deleteWarehouse(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Boolean> {
     return await deleteWarehouse(id, context)
   }
 
   @Directive('@privilege(category: "warehouse", privilege: "mutation")')
   @Directive('@transaction')
   @Mutation(returns => Boolean)
-  async deleteWarehouses(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<Boolean> {
+  async deleteWarehouses(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<Boolean> {
     return await deleteWarehouses(ids, context)
   }
 }
 
-export async function createWarehouse(warehouse: NewWarehouse, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+export async function createWarehouse(warehouse: NewWarehouse, context: ResolverContext) {
+  const { domain, user, tx } = context.state
 
   const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
   return await repository.save({
@@ -84,11 +87,11 @@ export async function createWarehouse(warehouse: NewWarehouse, context: any) {
   })
 }
 
-export async function updateWarehouse(id: string, patch: WarehousePatch, context: any) {
-  const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+export async function updateWarehouse(id: string, patch: WarehousePatch, context: ResolverContext) {
+  const { domain, user, tx } = context.state
 
   const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
-  const warehouse = await repository.findOne(id)
+  const warehouse = await repository.findOneBy({ id })
 
   return await repository.save({
     ...warehouse,
@@ -97,16 +100,16 @@ export async function updateWarehouse(id: string, patch: WarehousePatch, context
   })
 }
 
-export async function deleteWarehouse(id: string, context) {
-  const { tx }: { tx: EntityManager } = context.state
+export async function deleteWarehouse(id: string, context: ResolverContext) {
+  const { tx } = context.state
 
   const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
   await repository.delete(id)
   return true
 }
 
-export async function deleteWarehouses(ids: string[], context: any) {
-  const { tx }: { tx: EntityManager } = context.state
+export async function deleteWarehouses(ids: string[], context: ResolverContext) {
+  const { tx } = context.state
 
   const repository: Repository<Warehouse> = tx.getRepository(Warehouse)
   await repository.delete(ids)

package/server/service/warehouse/warehouse-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 { Warehouse } from './warehouse'
 import { WarehouseList } from './warehouse-types'
@@ -10,21 +9,22 @@ import { WarehouseList } from './warehouse-types'
 @Resolver(Warehouse)
 export class WarehouseQuery {
   @Query(returns => Warehouse)
-  async warehouse(@Arg('id') id: string, @Ctx() context: any): Promise<Warehouse> {
-    const { domain }: { domain: Domain } = context.state
+  async warehouse(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Warehouse> {
+    const { domain } = context.state
 
     return await getRepository(Warehouse).findOne({
       where: {
-        domain: domain,
-        name
+        domain: { id: domain.id },
+        id
+        /* name */
       },
       relations: ['domain', 'locations', 'creator', 'updater']
     })
   }
 
   @Query(returns => WarehouseList)
-  async warehouses(@Args() params: ListParam, @Ctx() context: any): Promise<WarehouseList> {
-    const { domain }: { domain: Domain } = context.state
+  async warehouses(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<WarehouseList> {
+    const { domain } = context.state
 
     const convertedParams = convertListParams(params, {
       domain: domain.id,
@@ -39,16 +39,16 @@ export class WarehouseQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() warehouse: Warehouse) {
-    return await getRepository(Domain).findOne(warehouse.domainId)
+    return await getRepository(Domain).findOneBy({ id: warehouse.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() warehouse: Warehouse) {
-    return await getRepository(User).findOne(warehouse.updaterId)
+    return await getRepository(User).findOneBy({ id: warehouse.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() warehouse: Warehouse) {
-    return await getRepository(User).findOne(warehouse.creatorId)
+    return await getRepository(User).findOneBy({ id: warehouse.creatorId })
   }
 }

package/server/service/warehouse/warehouse.ts

@@ -83,13 +83,13 @@ export class Warehouse {
 
   constructor(obj?) {
     if (obj) {
-      this.id = obj.Warehouse_id
-      this.name = obj.Warehouse_name
-      this.locations = obj.Warehouse_locations
-      this.type = obj.Warehouse_type
-      this.description = obj.Warehouse_description
-      this.createdAt = obj.Warehouse_created_at
-      this.updatedAt = obj.Warehouse_updated_at
+      this.id = obj.warehouse_id
+      this.name = obj.warehouse_name
+      this.locations = obj.warehouse_locations
+      this.type = obj.warehouse_type
+      this.description = obj.warehouse_description
+      this.createdAt = obj.warehouse_created_at
+      this.updatedAt = obj.warehouse_updated_at
     }
   }
 }

package/server/utils/inventory-util.ts

@@ -1,9 +1,9 @@
-import { EntityManager, getRepository, Repository } from 'typeorm'
+import { EntityManager, Repository } from 'typeorm'
 
 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 { Domain, getRepository } from '@things-factory/shell'
 
 import { INVENTORY_STATUS, INVENTORY_TRANSACTION_TYPE, LOCATION_STATUS, LOCATION_TYPE } from '../constants'
 import { Inventory, InventoryHistory, Location } from '../service'
@@ -229,10 +229,10 @@ export async function switchLocationStatus(
 ): Promise<Location> {
   const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
   const locationRepo: Repository<Location> = trxMgr?.getRepository(Location) || getRepository(Location)
-  const allocatedItemsCnt: number = await invRepo.count({
-    domain,
+  const allocatedItemsCnt: number = await invRepo.countBy({
+    domain: { id: domain.id },
     status: INVENTORY_STATUS.STORED,
-    location
+    location: { id: location.id }
   })
 
   if (!allocatedItemsCnt && location.status !== LOCATION_STATUS.EMPTY) {
@@ -259,9 +259,9 @@ export async function checkPalletDuplication(
   trxMgr?: EntityManager
 ): Promise<boolean> {
   const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
-  const duplicatedPalletCnt: number = await invRepo.count({
-    domain,
-    bizplace,
+  const duplicatedPalletCnt: number = await invRepo.countBy({
+    domain: { id: domain.id },
+    bizplace: { id: bizplace.id },
     palletId
   })
 
@@ -291,13 +291,13 @@ export async function checkPalletIdenticallity(
   const invRepo: Repository<Inventory> = trxMgr?.getRepository(Inventory) || getRepository(Inventory)
 
   if (typeof product === 'string') {
-    const foundProduct: Product = await productRepo.findOne(product)
+    const foundProduct: Product = await productRepo.findOneBy({ id: product }) /* TODO check migration typeorm 0.3 */
     if (!foundProduct) throw new Error(`Failed to find product with ${product}`)
     product = foundProduct
   }
 
   const inv: Inventory = await invRepo.findOne({
-    where: { domain, bizplace, palletId },
+    where: { domain: { id: domain.id }, bizplace, palletId },
     relations: ['product']
   })