@things-factory/integration-marketplace 5.0.7 → 6.0.0-alpha.0

package/server/graphql/resolvers/marketplace-store/delete-marketplace-stores.ts

@@ -1,12 +1,15 @@
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../entities'
 import { STORE_STATUS } from '../../constants'
 
 export const deleteMarketplaceStores = {
-  async deleteMarketplaceStores(_: any, { names }, context: any) {
+  async deleteMarketplaceStores(_: any, { names }, context: ResolverContext) {
     const { domain, user } = context.state
     const foundMarketplaceStores: MarketplaceStore[] = await getRepository(MarketplaceStore).find({
-      where: { domain, name: In(names) }
+      where: { domain: { id: domain.id }, name: In(names) }
     })
 
     const updatedMarketplaceStore = foundMarketplaceStores.map((store: MarketplaceStore) => {

package/server/graphql/resolvers/marketplace-store/lazada/deactivate-lazada-store.ts

@@ -1,12 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateLazadaStore = {
-  async deactivateLazadaStore(_: any, { name }, context: any) {
+  async deactivateLazadaStore(_: any, { name }, context: ResolverContext) {
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     var patch = {

package/server/graphql/resolvers/marketplace-store/lazada/generate-lazada-access-token.ts

@@ -10,11 +10,11 @@ const lazadaConfig = config.get('marketplaceIntegrationLazada', {})
 const { appKey, appSecret } = lazadaConfig
 
 export const generateLazadaAccessToken = {
-  async generateLazadaAccessToken(_: any, { id, code }, context: any) {
+  async generateLazadaAccessToken(_: any, { id, code }, context: ResolverContext) {
     const { domain, tx, user } = context.state
     const repository = tx.getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     const client = new Lazada(marketplaceStore.countryCode, appKey, appSecret)

package/server/graphql/resolvers/marketplace-store/lazada/get-lazada-auth-url.ts

@@ -3,7 +3,7 @@ const lazadaConfig = config.get('marketplaceIntegrationLazada', {})
 const { appKey, appSecret } = lazadaConfig
 
 export const getLazadaAuthURL = {
-  async getLazadaAuthURL(_: any, { redirectUrl }, context: any) {
+  async getLazadaAuthURL(_: any, { redirectUrl }, context: ResolverContext) {
     return `https://auth.lazada.com/oauth/authorize?response_type=code&force_auth=true&redirect_uri=${redirectUrl}&client_id=${appKey}`
   }
 }

package/server/graphql/resolvers/marketplace-store/magento/activate-magento-store.ts

@@ -7,9 +7,11 @@ import { STORE_STATUS } from '../../../constants'
 const debug = require('debug')('things-factory:integration-marketplace:activate-magento-store')
 
 export const activateMagentoStore = {
-  async activateMagentoStore(_: any, { marketplaceStoreId, username, password }, context: any) {
+  async activateMagentoStore(_: any, { marketplaceStoreId, username, password }, context: ResolverContext) {
     const { user, domain, tx } = context.state
-    let marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne(marketplaceStoreId)
+    let marketplaceStore: MarketplaceStore = await tx
+      .getRepository(MarketplaceStore)
+      .findOneBy({ id: marketplaceStoreId })
     let storeURL = marketplaceStore.storeURL
     storeURL = storeURL.replace(/\/$/, '')
 
@@ -60,7 +62,7 @@ export const activateMagentoStore = {
 
     marketplaceSettingCategories.forEach(async category => {
       const foundMarketplaceSetting: MarketplaceSetting = await tx.getRepository(MarketplaceSetting).findOne({
-        where: { marketplaceStore, domain, category }
+        where: { marketplaceStore: { id: marketplaceStore.id }, domain: { id: domain.id }, category }
       })
 
       if (!foundMarketplaceSetting) {

package/server/graphql/resolvers/marketplace-store/magento/deactivate-magento-store.ts

@@ -1,16 +1,16 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateMagentoStore = {
-  async deactivateMagentoStore(_: any, { name }, context: any) {
+  async deactivateMagentoStore(_: any, { name }, context: ResolverContext) {
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     var patch = {
-      storeId: '',
       accessToken: '',
       refreshToken: '',
       accessInfo: '',

package/server/graphql/resolvers/marketplace-store/magento/get-magento-auth-url.ts

@@ -1,9 +1,10 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 
 export const getMagentoAuthURL = {
-  async getMagentoAuthURL(_: any, { marketplaceStoreId }, context: any) {
-    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOne(marketplaceStoreId)
+  async getMagentoAuthURL(_: any, { marketplaceStoreId }, context: ResolverContext) {
+    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId })
     storeURL = storeURL.replace(/\/$/, '')
 
     return `${storeURL}/rest/V1/integration/admin/token`

package/server/graphql/resolvers/marketplace-store/marketplace-store.ts

@@ -1,12 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../entities'
 
 export const marketplaceStoreResolver = {
-  async marketplaceStore(_: any, { id }, context: any) {
+  async marketplaceStore(_: any, { id }, context: ResolverContext) {
     const { domain } = context.state
 
     return await getRepository(MarketplaceStore).findOne({
-      where: { domain, id },
+      where: { domain: { id: domain.id }, id },
       relations: ['domain', 'creator', 'updater']
     })
   }

package/server/graphql/resolvers/marketplace-store/marketplace-stores.ts

@@ -1,9 +1,9 @@
-import { ListParam, buildQuery } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
+import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../entities'
 
 export const marketplaceStoresResolver = {
-  async marketplaceStores(_: any, params: ListParam, context: any) {
+  async marketplaceStores(_: any, params: ListParam, context: ResolverContext) {
     const queryBuilder = getRepository(MarketplaceStore).createQueryBuilder('MS')
     buildQuery(queryBuilder, params, context)
 

package/server/graphql/resolvers/marketplace-store/shopee/deactivate-shopee-store.ts

@@ -1,12 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateShopeeStore = {
-  async deactivateShopeeStore(_: any, { name }, context: any) {
+  async deactivateShopeeStore(_: any, { name }, context: ResolverContext) {
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     var patch = {

package/server/graphql/resolvers/marketplace-store/shopee/generate-shopee-access-token.ts

@@ -14,11 +14,11 @@ const { partnerId, partnerKey, isUAT } = shopeeConfig
 const debug = Debug('things-factory:integration-marketplace:generate-shopee-access-token')
 
 export const generateShopeeAccessToken = {
-  async generateShopeeAccessToken(_: any, { id, code, shopId }, context: any) {
+  async generateShopeeAccessToken(_: any, { id, code, shopId }, context: ResolverContext) {
     const { domain, tx, user } = context.state
     const repository = tx.getRepository(MarketplaceStore)
     const marketplaceStore: MarketplaceStore = await repository.findOne({
-      where: { domain: context.state.domain, id }
+      where: { domain: { id: context.state.domain.id }, id }
     })
 
     const timestamp = Math.round(new Date().getTime() / 1000)
@@ -72,7 +72,7 @@ export const generateShopeeAccessToken = {
 
     marketplaceSettingCategories.forEach(async category => {
       const foundMarketplaceSetting: MarketplaceSetting = await tx.getRepository(MarketplaceSetting).findOne({
-        where: { marketplaceStore, domain, category }
+        where: { marketplaceStore: { id: marketplaceStore.id }, domain: { id: domain.id }, category }
       })
 
       if (!foundMarketplaceSetting) {

package/server/graphql/resolvers/marketplace-store/shopee/get-shopee-auth-url.ts

@@ -5,7 +5,7 @@ const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
 const { partnerId, partnerKey, isUAT } = shopeeConfig
 
 export const getShopeeAuthURL = {
-  async getShopeeAuthURL(_: any, { redirectUrl, cancel = false }, context: any) {
+  async getShopeeAuthURL(_: any, { redirectUrl, cancel = false }, context: ResolverContext) {
     const client = new Shopee({
       isUAT,
       partner_id: partnerId,

package/server/graphql/resolvers/marketplace-store/shopify/deactivate-shopify-store.ts

@@ -1,14 +1,15 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateShopifyStore = {
-  async deactivateShopifyStore(_: any, { name }, context: any) {
+  async deactivateShopifyStore(_: any, { name }, context: ResolverContext) {
     const { domain, user } = context.state
 
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     var patch = {

package/server/graphql/resolvers/marketplace-store/shopify/get-shopify-auth-url.ts

@@ -1,14 +1,14 @@
-import { Shopify } from '../../../../controllers/shopify'
-
-import { getRepository } from 'typeorm'
 import { VerificationToken, VerificationTokenType } from '@things-factory/auth-base'
 import { config } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+
+import { Shopify } from '../../../../controllers/shopify'
 
 const shopifyConfig = config.get('marketplaceIntegrationShopify', {})
 const { apiKey, apiSecret } = shopifyConfig
 
 export const getShopifyAuthURL = {
-  async getShopifyAuthURL(_: any, { marketplaceStoreId, storeId, redirectUrl }, context: any) {
+  async getShopifyAuthURL(_: any, { marketplaceStoreId, storeId, redirectUrl }, context: ResolverContext) {
     const { user } = context.state
     const shopify = new Shopify({ apiKey, apiSecret, shop: storeId })
 

package/server/graphql/resolvers/marketplace-store/update-marketplace-store.ts

@@ -1,12 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../entities'
 
 export const updateMarketplaceStore = {
-  async updateMarketplaceStore(_: any, { name, patch }, context: any) {
+  async updateMarketplaceStore(_: any, { name, patch }, context: ResolverContext) {
     const { domain, user } = context.state
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     return await repository.save({

package/server/graphql/resolvers/marketplace-store/update-multiple-marketplace-store.ts

@@ -1,8 +1,9 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../entities'
 
 export const updateMultipleMarketplaceStore = {
-  async updateMultipleMarketplaceStore(_: any, { patches }, context: any) {
+  async updateMultipleMarketplaceStore(_: any, { patches }, context: ResolverContext) {
     const { domain, user } = context.state
 
     let results = []
@@ -28,7 +29,7 @@ export const updateMultipleMarketplaceStore = {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const marketplaceStore = await marketplaceStoreRepo.findOne(newRecord.id)
+        const marketplaceStore = await marketplaceStoreRepo.findOneBy({ id: newRecord.id })
 
         const result = await marketplaceStoreRepo.save({
           ...marketplaceStore,

package/server/graphql/resolvers/marketplace-store/woocommerce/deactivate-woocommerce-store.ts

@@ -1,13 +1,13 @@
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateWoocommerceStore = {
-  async deactivateWoocommerceStore(_: any, { name }, context: any): Promise<MarketplaceStore> {
-    const { domain }: { domain: Domain } = context.state
+  async deactivateWoocommerceStore(_: any, { name }, context: ResolverContext): Promise<MarketplaceStore> {
+    const { domain } = context.state
     let marketplaceStore: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
 
     marketplaceStore.storeId = ''

package/server/graphql/resolvers/marketplace-store/woocommerce/get-woocommerce-auth-url.ts

@@ -1,11 +1,12 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 
 export const getWoocommerceAuthURL = {
-  async getWoocommerceAuthURL(_: any, { marketplaceStoreId, redirectUrl }, context: any) {
+  async getWoocommerceAuthURL(_: any, { marketplaceStoreId, redirectUrl }, context: ResolverContext) {
     const appName: string = context.request.header.origin
     const returnURL: string = context.request.header.referer
-    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOne(marketplaceStoreId)
+    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId })
     storeURL = storeURL.replace(/\/$/, '')
 
     return `${storeURL}/wc-auth/v1/authorize?app_name=${appName}&user_id=${marketplaceStoreId}&return_url=${returnURL}&callback_url=${redirectUrl}&scope=read_write`

package/server/graphql/resolvers/marketplace-store/zalora/deactivate-zalora-store.ts

@@ -1,12 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const deactivateZaloraStore = {
-  async deactivateZaloraStore(_: any, { name }, context: any) {
+  async deactivateZaloraStore(_: any, { name }, context: ResolverContext) {
     const repository = getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain: context.state.domain, name }
+      where: { domain: { id: context.state.domain.id }, name }
     })
 
     var patch = {

package/server/graphql/resolvers/marketplace-store/zalora/generate-zalora-access-token.ts

@@ -4,11 +4,11 @@ import { MarketplaceSetting, MarketplaceStore } from '../../../../entities'
 import { STORE_STATUS } from '../../../constants'
 
 export const generateZaloraAccessToken = {
-  async generateZaloraAccessToken(_: any, { id, apiKey, userId, countryCode }, context: any) {
+  async generateZaloraAccessToken(_: any, { id, apiKey, userId, countryCode }, context: ResolverContext) {
     const { domain, user, tx } = context.state
     const repository = tx.getRepository(MarketplaceStore)
     const marketplaceStore: any = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     var patch = {

package/server/graphql/resolvers/marketplace-transporter/create-marketplace-transporter.ts

@@ -1,16 +1,18 @@
-import { CourierService } from '@things-factory/integration-lmd'
 import { v4 as uuidv4 } from 'uuid'
+
+import { CourierService } from '@things-factory/integration-lmd'
+
 import { MarketplaceStore, MarketplaceTransporter } from '../../../entities'
 
 export const createMarketplaceTransporter = {
-  async createMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: any) {
+  async createMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: ResolverContext) {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(MarketplaceTransporter).save({
       name: uuidv4().toString(),
-      marketplaceStore: await tx.getRepository(MarketplaceStore).findOne(marketplaceStoreId),
-      deliveryTransporter: await tx.getRepository(CourierService).findOne(deliveryTransporter),
-      pickupTransporter: await tx.getRepository(CourierService).findOne(deliveryTransporter),
+      marketplaceStore: await tx.getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId }),
+      deliveryTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      pickupTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
       domain,
       creator: user,
       updater: user

package/server/graphql/resolvers/marketplace-transporter/delete-marketplace-transporter.ts

@@ -1,13 +1,13 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceTransporter } from '../../../entities'
 
 export const deleteMarketplaceTransporter = {
-  async deleteMarketplaceTransporter(_: any, { name }, context: any) {
+  async deleteMarketplaceTransporter(_: any, { name }, context: ResolverContext) {
     const { domain, user } = context.state
 
     await getRepository(MarketplaceTransporter).delete({ domain, name })
-    
+
     return true
   }
 }
-

package/server/graphql/resolvers/marketplace-transporter/delete-marketplace-transporters.ts

@@ -1,16 +1,18 @@
-import { getRepository, In } from 'typeorm'
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceTransporter } from '../../../entities'
 
 export const deleteMarketplaceTransporters = {
-  async deleteMarketplaceTransporters(_: any, { names }, context: any) {
+  async deleteMarketplaceTransporters(_: any, { names }, context: ResolverContext) {
     const { domain, user } = context.state
 
-    await getRepository(MarketplaceTransporter).delete({ 
-        domain,
-        name: In(names)
+    await getRepository(MarketplaceTransporter).delete({
+      domain,
+      name: In(names)
     })
-    
+
     return true
   }
 }
-

package/server/graphql/resolvers/marketplace-transporter/marketplace-transporter-query.ts

@@ -1,22 +1,24 @@
-import { convertListParams, ListParam, Domain } from '@things-factory/shell'
-import { getRepository, EntityManager } from 'typeorm'
-import { MarketplaceTransporter as MarketplaceTransporterEntity, MarketplaceStore } from '../../../entities'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceStore, MarketplaceTransporter as MarketplaceTransporterEntity } from '../../../entities'
 
 export const Query = {
-  async marketplaceTransporter(_: any, { marketplaceStoreId }, context: any) {
-    const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
-    const marketplaceStore: MarketplaceStore = await tx.getRepository(MarketplaceStore).findOne(marketplaceStoreId)
+  async marketplaceTransporter(_: any, { marketplaceStoreId }, context: ResolverContext) {
+    const { domain, tx } = context.state
+    const marketplaceStore: MarketplaceStore = await tx
+      .getRepository(MarketplaceStore)
+      .findOneBy({ id: marketplaceStoreId })
 
     const marketplaceTransporter = await tx.getRepository(MarketplaceTransporterEntity).findOne({
-      where: { domain, marketplaceStore },
+      where: { domain: { id: domain.id }, marketplaceStore: { id: marketplaceStore.id } },
       relations: ['marketplaceStore', 'deliveryTransporter', 'pickupTransporter']
     })
 
     return marketplaceTransporter
   },
 
-  async marketplaceTransporters(_: any, params: ListParam, context: any) {
-    const { tx }: { tx: EntityManager } = context.state
+  async marketplaceTransporters(_: any, params: ListParam, context: ResolverContext) {
+    const { tx } = context.state
 
     const convertedParams = convertListParams(params)
     const [items, total] = await tx.getRepository(MarketplaceTransporterEntity).findAndCount({
@@ -31,7 +33,8 @@ export const Query = {
 export const MarketplaceTransporter = {
   async domain(marketplaceTransporter) {
     return (
-      await getRepository(MarketplaceTransporterEntity).findOne(marketplaceTransporter.id, {
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
         relations: ['domain']
       })
     )?.domain
@@ -39,7 +42,8 @@ export const MarketplaceTransporter = {
 
   async creator(marketplaceTransporter) {
     return (
-      await getRepository(MarketplaceTransporterEntity).findOne(marketplaceTransporter.id, {
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
         relations: ['creator']
       })
     )?.creator
@@ -47,7 +51,8 @@ export const MarketplaceTransporter = {
 
   async updater(marketplaceTransporter) {
     return (
-      await getRepository(MarketplaceTransporterEntity).findOne(marketplaceTransporter.id, {
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
         relations: ['updater']
       })
     )?.updater

package/server/graphql/resolvers/marketplace-transporter/update-marketplace-transporter.ts

@@ -1,20 +1,24 @@
-import { MarketplaceTransporter, MarketplaceStore } from '../../../entities'
-import { CourierSerivce } from '@things-factory/integration-lmd'
+import { CourierService } from '@things-factory/integration-lmd'
+
+import { MarketplaceTransporter } from '../../../entities'
 
 export const updateMarketplaceTransporter = {
-  async updateMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: any) {
+  async updateMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: ResolverContext) {
     const { domain, user, tx } = context.state
     const marketplaceTransporterRepo = tx.getRepository(MarketplaceTransporter)
 
     const marketplaceTransporter: MarketplaceTransporter = await marketplaceTransporterRepo.findOne({
-      where: { domain, marketplaceStore: await tx.getRepository(MarketplaceStore).findOne(marketplaceStoreId) },
+      where: {
+        domain: { id: domain.id },
+        marketplaceStore: { id: marketplaceStoreId }
+      },
       relations: ['deliveryTransporter', 'pickupTransporter']
     })
 
     return await marketplaceTransporterRepo.save({
       ...marketplaceTransporter,
-      deliveryTransporter: await tx.getRepository(CourierSerivce).findOne(deliveryTransporter),
-      pickupTransporter: await tx.getRepository(CourierSerivce).findOne(deliveryTransporter),
+      deliveryTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      pickupTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
       updater: user
     })
   }

package/server/graphql/resolvers/marketplace-transporter/update-multiple-marketplace-transporter.ts

@@ -1,46 +1,49 @@
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { MarketplaceTransporter } from '../../../entities'
 
 export const updateMultipleMarketplaceTransporter = {
-  async updateMultipleMarketplaceTransporter(_: any, { patches }, context: any) {
+  async updateMultipleMarketplaceTransporter(_: any, { patches }, context: ResolverContext) {
     const { domain, user } = context.state
-    
+
     let results = []
     const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
     const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
     const marketplaceTransporterRepo = getRepository(MarketplaceTransporter)
 
     if (_createRecords.length > 0) {
-        for (let i = 0; i < _createRecords.length; i++) {
-          const newRecord = _createRecords[i]
-          
-          const result = await marketplaceTransporterRepo.save({
-            ...newRecord,
-            domain: domain,
-            creator: user,
-            updater: user,
-          })
-          
-          results.push({ ...result, cuFlag: '+' })
-        }
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceTransporterRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
     }
 
     if (_updateRecords.length > 0) {
-        for (let i = 0; i < _updateRecords.length; i++) {
-          const newRecord = _updateRecords[i]
-          const marketplaceTransporter = await marketplaceTransporterRepo.findOne({ domain, id: newRecord.id})
-  
-          const result = await marketplaceTransporterRepo.save({
-            ...marketplaceTransporter,
-            ...newRecord,
-            updater: user
-          })
-  
-          results.push({ ...result, cuFlag: 'M' })
-        }
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceTransporter = await marketplaceTransporterRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        const result = await marketplaceTransporterRepo.save({
+          ...marketplaceTransporter,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
     }
-  
+
     return results
   }
 }
-

package/server/graphql/resolvers/store-order/accept-store-order-cancellation.ts

@@ -1,7 +1,7 @@
 import { StoreAPI } from '../../../controllers/store-api'
 
 export const acceptStoreOrderCancellation = {
-  async acceptStoreOrderCancellation(_: any, { storeId, orderId }, context: any) {
+  async acceptStoreOrderCancellation(_: any, { storeId, orderId }, context: ResolverContext) {
     // only in Shopee, to accept buyer order cancellation
     var store = await StoreAPI.getMarketplaceStore(storeId)
     return await StoreAPI.acceptStoreOrderCancellation(store, orderId)

package/server/graphql/resolvers/store-order/cancel-store-order.ts

@@ -1,7 +1,7 @@
 import { StoreAPI } from '../../../controllers/store-api'
 
 export const cancelStoreOrder = {
-  async cancelStoreOrder(_: any, { storeId, cancelInformation }, context: any) {
+  async cancelStoreOrder(_: any, { storeId, cancelInformation }, context: ResolverContext) {
     var store = await StoreAPI.getMarketplaceStore(storeId)
     return await StoreAPI.cancelStoreOrder(store, cancelInformation)
   }

package/server/graphql/resolvers/store-order/get-store-order-document.ts

@@ -1,7 +1,7 @@
 import { StoreAPI } from '../../../controllers/store-api'
 
 export const getStoreOrderDocument = {
-  async getStoreOrderDocument(_: any, { storeId, docType, orderItemId }, context: any) {
+  async getStoreOrderDocument(_: any, { storeId, docType, orderItemId }, context: ResolverContext) {
     var store = await StoreAPI.getMarketplaceStore(storeId)
     return await StoreAPI.getStoreOrderDocument(store, { docType, orderItemId })
   }