@things-factory/marketplace-base 8.0.7 → 9.0.0-beta.12

package/server/graphql/resolvers/marketplace-order/sync-marketplace-orders-by-platform.ts

@@ -1,31 +0,0 @@
-import { MarketplaceStore } from '@things-factory/integration-marketplace'
-import { getRepository } from '@things-factory/shell'
-
-import { syncMarketplaceOrder } from './sync-marketplace-order'
-
-export const syncMarketplaceOrdersByPlatform = {
-  async syncMarketplaceOrdersByPlatform(
-    _: any,
-    { fromCreatedDate, toCreatedDate, blackListStores },
-    context: ResolverContext
-  ) {
-    let stores: MarketplaceStore[] = await getRepository(MarketplaceStore).find({
-      where: { status: 'ACTIVE' }
-    })
-
-    if (blackListStores) {
-      blackListStores = blackListStores.split(',')
-      stores = stores.filter(store => blackListStores.indexOf(store.name) < 0)
-    }
-
-    for (let store of stores) {
-      syncMarketplaceOrder.syncMarketplaceOrder(
-        _,
-        { storeId: store.id, fromCreatedDate, toCreatedDate, scheduler: true },
-        context
-      )
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order/sync-shopee-awb.ts

@@ -1,49 +0,0 @@
-import { createQueryBuilder } from 'typeorm'
-
-import { StoreAPI } from '@things-factory/integration-marketplace'
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
-
-export const syncShopeeAwb = {
-  async syncShopeeAwb(_: any, {}, context: ResolverContext) {
-    let marketplaceOrders: MarketplaceOrder[] = await getRepository(MarketplaceOrder)
-      .createQueryBuilder('mo')
-      .select('mo')
-      .addSelect('ms')
-      .distinctOn(['mo.name'])
-      .innerJoin('mo.marketplaceStore', 'ms')
-      .innerJoin('marketplace_order_shippings', 'mos', 'mo.name = mos.order_no_ref')
-      .where('ms.platform = :platform', { platform: 'shopee' })
-      .andWhere('ms.status = :ms_status', { ms_status: 'ACTIVE' })
-      .andWhere('ms.is_own_transport = false')
-      .andWhere('mo.status = :status', { status: 'processed' })
-      .andWhere('mos.airway_bill is null')
-      .getMany()
-
-    for (let marketplaceOrder of marketplaceOrders) {
-      let docResult
-      try {
-        docResult = await StoreAPI.getShippingDocumentResult(marketplaceOrder.marketplaceStore, {
-          orderNo: [marketplaceOrder.name]
-        })
-      } catch (e) {
-        await StoreAPI.createShippingDocument(marketplaceOrder.marketplaceStore, {
-          orderNo: marketplaceOrder.name
-        })
-      }
-      if (docResult) {
-        let downloadResult = await StoreAPI.getStoreOrderDocument(marketplaceOrder.marketplaceStore, {
-          docRefNo: [marketplaceOrder.name],
-          docType: 'shippingLabel'
-        })
-        await createQueryBuilder()
-          .update(MarketplaceOrderShipping)
-          .set({ airwayBill: downloadResult[0].airwayBill })
-          .where('order_no_ref = :order_no_ref', { order_no_ref: marketplaceOrder.name })
-          .execute()
-      }
-    }
-    return true
-  }
-}

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

@@ -1,35 +0,0 @@
-import {
-  MarketplaceOrder as MarketplaceOrderEntity,
-  MarketplaceOrderItem as MarketplaceOrderItemEntity
-} from '../../../entities'
-
-export const updateMarketplaceOrder = {
-  async updateMarketplaceOrder(_: any, { orderNo, patch }, context: ResolverContext) {
-    const { tx, user, marketplaceStore } = context.state
-    let marketplaceOrder: MarketplaceOrderEntity = await tx.getRepository(MarketplaceOrderEntity).findOne({
-      where: { marketplaceStore: { id: marketplaceStore.id }, orderNo },
-      relations: ['marketplaceStore', 'marketplaceOrderItems', 'marketplaceOrderItems.marketplaceProductVariation']
-    })
-
-    let marketplaceOrderItems: MarketplaceOrderItemEntity[] = marketplaceOrder.marketplaceOrderItems
-    marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderItem => {
-      return {
-        ...marketplaceOrderItem,
-        ...patch,
-        updater: user
-      }
-    })
-
-    marketplaceOrder = await tx.getRepository(MarketplaceOrderEntity).save({
-      ...marketplaceOrder,
-      ...patch,
-      updater: user
-    })
-
-    marketplaceOrderItems = await tx.getRepository(MarketplaceOrderItemEntity).save(marketplaceOrderItems)
-
-    return {
-      ...marketplaceOrder
-    }
-  }
-}

package/server/graphql/resolvers/marketplace-order/update-order-ready-to-ship.ts

@@ -1,142 +0,0 @@
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-import { Domain } from '@things-factory/shell'
-
-import {
-  MarketplaceOrder,
-  MarketplaceOrderItem,
-  MarketplaceOrderShipping,
-  MarketplaceOrderShippingItem
-} from '../../../entities'
-
-export const updateOrderReadyToShip = {
-  async updateOrderReadyToShip(
-    _: any,
-    { shippingProvider, deliveryType, orderNo, orderId, domainId },
-    context: ResolverContext
-  ) {
-    const { tx } = context.state
-
-    const domain: Domain = await tx.getRepository(Domain).findOneBy({ id: domainId })
-
-    let foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { name: orderId, orderNo, domain: { id: domain.id } },
-      relations: [
-        'marketplaceStore',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-        'marketplaceOrderItems.marketplaceProductVariation'
-      ]
-    })
-    if (!foundMarketplaceOrder) throw new Error('No order is found')
-
-    const storeId = foundMarketplaceOrder.marketplaceStore.id
-    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-
-    let trackingInfoArr: any[] = []
-    let marketplaceOrderShippings: MarketplaceOrderShipping[] = []
-
-    foundMarketplaceOrder.marketplaceOrderItems.map(item => {
-      const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = item.marketplaceOrderShippingItems
-      marketplaceOrderShippingItems.map(itm => {
-        if (itm?.marketplaceOrderShipping) {
-          marketplaceOrderShippings.push(itm.marketplaceOrderShipping)
-        }
-      })
-    })
-
-    const uniqueMarketplaceOrderShippings = Array.from(new Set(marketplaceOrderShippings.map(a => a.id))).map(id => {
-      return marketplaceOrderShippings.find(a => a.id === id)
-    })
-
-    if (marketplaceStore.platform === 'lazada') {
-      if (
-        uniqueMarketplaceOrderShippings.some(marketplaceOrderShipping => marketplaceOrderShipping.trackingNo != null)
-      ) {
-        uniqueMarketplaceOrderShippings.map((orderShipping: MarketplaceOrderShipping) => {
-          if (orderShipping?.trackingNo) {
-            const trackingNoInfo: any[] = JSON.parse(orderShipping.trackingNo)
-            const orderTrackingNos: string[] = trackingNoInfo.map(item => item.tracking_code)
-            const uniqueTrackingNos = [...new Set(orderTrackingNos)]
-
-            let orderItemIds: string[] = []
-
-            if (uniqueTrackingNos?.length == 1) {
-              orderItemIds = trackingNoInfo.map(item => item.order_item_id)
-              trackingInfoArr.push({ orderItemIds, trackingNo: uniqueTrackingNos[0] })
-            } else {
-              uniqueTrackingNos.map(trackingNo => {
-                orderItemIds = trackingNoInfo
-                  .filter(info => info.tracking_code === trackingNo)
-                  .map(filteredInfo => filteredInfo.order_item_id)
-
-                trackingInfoArr.push({ orderItemIds, trackingNo })
-              })
-            }
-          }
-        })
-      }
-
-      for (var i = 0; i < trackingInfoArr?.length; i++) {
-        const trackingInfo = trackingInfoArr[i]
-        const trackingNo = trackingInfo.trackingNo
-        const orderItemId = trackingInfo.orderItemIds
-
-        const res = await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
-          shipmentProvider: shippingProvider,
-          deliveryType,
-          orderItemId,
-          trackingNo
-        })
-      }
-    } else {
-      let mos = uniqueMarketplaceOrderShippings.filter(mos => mos.trackingNo != null || mos.ownTrackingNo != null)
-      if (mos.length > 0) {
-        let trackingNo = mos[0].ownTrackingNo
-        const note = mos[0].trackingUrl || trackingNo
-
-        const res = await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
-          orderId,
-          trackingUrl: mos[0].trackingUrl || '',
-          trackingNo,
-          order: foundMarketplaceOrder,
-          note
-        })
-
-        if (marketplaceStore.platform === 'woocommerce') {
-          await StoreAPI.updateOrderStatus(marketplaceStore, {
-            orderId,
-            status: 'DELIVERED'
-          })
-        }
-      }
-    }
-
-    const updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId })
-
-    foundMarketplaceOrder.status = updatedOrder.status
-    foundMarketplaceOrder.orderUpdatedAt = updatedOrder.orderUpdatedAt
-    foundMarketplaceOrder.trackingNo = updatedOrder.trackingNo
-    foundMarketplaceOrder.shippingProvider = updatedOrder.shippingProvider
-    await tx.getRepository(MarketplaceOrder).save(foundMarketplaceOrder)
-
-    for (let idx = 0; idx < foundMarketplaceOrder.marketplaceOrderItems.length; idx++) {
-      let matchItem = updatedOrder.orderItems.find(
-        i => i.variationId == foundMarketplaceOrder.marketplaceOrderItems[idx].marketplaceProductVariation.variationId
-      )
-
-      if (matchItem) {
-        let targetMarketplaceOrderItem = {
-          ...foundMarketplaceOrder.marketplaceOrderItems[idx],
-          shippingProvider: matchItem.shippingProvider,
-          trackingCode: matchItem.trackingNo,
-          status: matchItem.status
-        }
-
-        await tx.getRepository(MarketplaceOrderItem).save(targetMarketplaceOrderItem)
-      }
-    }
-
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/create-marketplace-order-item.ts

@@ -1,14 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const createMarketplaceOrderItem = {
-  async createMarketplaceOrderItem(_: any, { marketplaceOrderItem }, context: ResolverContext) {
-    return await getRepository(MarketplaceOrderItem).save({
-      ...marketplaceOrderItem,
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/delete-marketplace-order-item.ts

@@ -1,10 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const deleteMarketplaceOrderItem = {
-  async deleteMarketplaceOrderItem(_: any, { name }, context: ResolverContext) {
-    await getRepository(MarketplaceOrderItem).delete({ domain: { id: context.state.domain.id }, name })
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/delete-marketplace-order-items.ts

@@ -1,17 +0,0 @@
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const deleteMarketplaceOrderItems = {
-  async deleteMarketplaceOrderItems(_: any, { names }, context: ResolverContext) {
-    const { domain } = context.state
-
-    await getRepository(MarketplaceOrderItem).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/index.ts

@@ -1,22 +0,0 @@
-import { marketplaceOrderItemResolver } from './marketplace-order-item'
-import { marketplaceOrderItemsResolver } from './marketplace-order-items'
-
-import { updateMarketplaceOrderItem } from './update-marketplace-order-item'
-import { updateMultipleMarketplaceOrderItem } from './update-multiple-marketplace-order-item'
-import { createMarketplaceOrderItem } from './create-marketplace-order-item'
-import { deleteMarketplaceOrderItem } from './delete-marketplace-order-item'
-import { deleteMarketplaceOrderItems } from './delete-marketplace-order-items'
-
-export const MarketplaceOrderItemResolver = {
-  Query: {
-    ...marketplaceOrderItemsResolver,
-    ...marketplaceOrderItemResolver
-  },
-  Mutation: {
-    ...updateMarketplaceOrderItem,
-    ...updateMultipleMarketplaceOrderItem,
-    ...createMarketplaceOrderItem,
-    ...deleteMarketplaceOrderItem,
-    ...deleteMarketplaceOrderItems
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/marketplace-order-item.ts

@@ -1,14 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const marketplaceOrderItemResolver = {
-  async marketplaceOrderItem(_: any, { name }, context: ResolverContext) {
-    const repository = getRepository(MarketplaceOrderItem)
-
-    return await getRepository(MarketplaceOrderItem).findOne({
-      where: { domain: { id: context.state.domain.id }, name },
-      relations: ['domain', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/marketplace-order-items.ts

@@ -1,15 +0,0 @@
-import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const marketplaceOrderItemsResolver = {
-  async marketplaceOrderItems(_: any, params: ListParam, context: ResolverContext) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(MarketplaceOrderItem).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater']
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/update-marketplace-order-item.ts

@@ -1,18 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderItem } from '../../../entities'
-
-export const updateMarketplaceOrderItem = {
-  async updateMarketplaceOrderItem(_: any, { name, patch }, context: ResolverContext) {
-    const repository = getRepository(MarketplaceOrderItem)
-    const marketplaceOrderItem = await repository.findOne({
-      where: { domain: { id: context.state.domain.id }, name }
-    })
-
-    return await repository.save({
-      ...marketplaceOrderItem,
-      ...patch,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order-item/update-multiple-marketplace-order-item.ts

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

package/server/graphql/resolvers/marketplace-order-shipping/create-marketplace-order-shipping.ts

@@ -1,14 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const createMarketplaceOrderShipping = {
-  async createMarketplaceOrderShipping(_: any, { marketplaceOrderShipping }, context: ResolverContext) {
-    return await getRepository(MarketplaceOrderShipping).save({
-      ...marketplaceOrderShipping,
-      domain: context.state.domain,
-      creator: context.state.user,
-      updater: context.state.user
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/delete-marketplace-order-shipping.ts

@@ -1,10 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const deleteMarketplaceOrderShipping = {
-  async deleteMarketplaceOrderShipping(_: any, { name }, context: ResolverContext) {
-    await getRepository(MarketplaceOrderShipping).delete({ domain: { id: context.state.domain.id }, name })
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/delete-marketplace-order-shippings.ts

@@ -1,17 +0,0 @@
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const deleteMarketplaceOrderShippings = {
-  async deleteMarketplaceOrderShippings(_: any, { names }, context: ResolverContext) {
-    const { domain } = context.state
-
-    await getRepository(MarketplaceOrderShipping).delete({
-      domain: { id: domain.id },
-      name: In(names)
-    })
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/index.ts

@@ -1,23 +0,0 @@
-import { createMarketplaceOrderShipping } from './create-marketplace-order-shipping'
-import { deleteMarketplaceOrderShipping } from './delete-marketplace-order-shipping'
-import { deleteMarketplaceOrderShippings } from './delete-marketplace-order-shippings'
-import { marketplaceOrderShippingResolver } from './marketplace-order-shipping'
-import { marketplaceOrderShippingsResolver } from './marketplace-order-shippings'
-import { marketplaceOrderShippingsForBatchInitResolver } from './marketplace-order-shippings-for-batch-init'
-import { updateMarketplaceOrderShipping } from './update-marketplace-order-shipping'
-import { updateMultipleMarketplaceOrderShipping } from './update-multiple-marketplace-order-shipping'
-
-export const MarketplaceOrderShippingResolver = {
-  Query: {
-    ...marketplaceOrderShippingsResolver,
-    ...marketplaceOrderShippingResolver,
-    ...marketplaceOrderShippingsForBatchInitResolver
-  },
-  Mutation: {
-    ...updateMarketplaceOrderShipping,
-    ...updateMultipleMarketplaceOrderShipping,
-    ...createMarketplaceOrderShipping,
-    ...deleteMarketplaceOrderShipping,
-    ...deleteMarketplaceOrderShippings
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/marketplace-order-shipping.ts

@@ -1,25 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const marketplaceOrderShippingResolver = {
-  async marketplaceOrderShipping(_: any, { name }, context: ResolverContext) {
-    const repository = getRepository(MarketplaceOrderShipping)
-
-    const items: MarketplaceOrderShipping = await repository.findOne({
-      where: { domain: { id: context.state.domain.id }, name },
-      relations: [
-        'domain',
-        'creator',
-        'updater',
-        'marketplaceOrderShippingItems',
-        'marketplaceOrderShippingItems.product',
-        'marketplaceOrderShippingItems.marketplaceOrderItem',
-        'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation',
-        'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation.marketplaceProduct'
-      ]
-    })
-
-    return items
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/marketplace-order-shippings-for-batch-init.ts

@@ -1,88 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
-import { getLogisticsParam } from '../marketplace-order/get-logistics-param'
-
-export const marketplaceOrderShippingsForBatchInitResolver = {
-  async marketplaceOrderShippingsForBatchInit(_: any, params: ListParam, context: ResolverContext) {
-    try {
-      const statusFilter: any = params.filters.filter(filter => filter.name === 'status')
-      let paramsFilters: any[] = params.filters.filter(
-        filter => filter.name !== 'status' && filter.name != 'logisticsType'
-      )
-      let paramListParams: any = {
-        filters: [...paramsFilters],
-        pagination: params.pagination
-      }
-
-      let sortings = params.sortings
-
-      let qb: SelectQueryBuilder<MarketplaceOrderShipping> =
-        getRepository(MarketplaceOrderShipping).createQueryBuilder('mos')
-      buildQuery(qb, paramListParams, context)
-
-      qb.leftJoinAndSelect('mos.marketplaceStore', 'marketplaceStore')
-      qb.leftJoinAndMapOne('mos.marketplaceOrder', MarketplaceOrder, 'mo', 'mo.order_no = mos.order_no_ref')
-      qb.andWhere('mo.status NOT IN (:...statuses)', { statuses: statusFilter[0].value })
-
-      if (sortings?.length !== 0) {
-        const sorter = (sortings || []).reduce((acc, sort) => {
-          const order: string = sort.desc ? 'DESC' : 'ASC'
-
-          switch (sort.name) {
-            case 'orderNoRef':
-              acc = { ...acc, ['mos.orderNoRef']: order }
-              break
-
-            case 'shippingProvider':
-              acc = { ...acc, ['mos.transporter']: order }
-              break
-
-            case 'ownShippingProvider':
-              acc = { ...acc, ['mos.ownTransporter']: order }
-              break
-
-            case 'status':
-              acc = { ...acc, ['mo.status']: order }
-              break
-
-            case 'orderCreatedAt':
-              acc = { ...acc, ['mo.orderCreatedAt']: order }
-              break
-
-            case 'orderUpdatedAt':
-              acc = { ...acc, ['mo.orderUpdatedAt']: order }
-              break
-          }
-
-          return acc
-        }, {})
-        qb.orderBy(sorter)
-      }
-
-      let [items, total] = await qb.getManyAndCount()
-
-      items = await Promise.all(
-        items.map(async (itm: any) => {
-          if (itm.marketplaceStore.platform == 'shopee' && itm.status === 'ready_to_ship') {
-            let fullLogisticsDetail = await getLogisticsParam.getLogisticsParam(
-              _,
-              { storeId: itm.marketplaceStore.id, orderNo: itm.orderNo },
-              context
-            )
-
-            return { ...itm, fullLogisticsDetail }
-          } else {
-            return itm
-          }
-        })
-      )
-
-      return { items: items.filter(itm => itm), total }
-    } catch (e) {
-      throw e
-    }
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/marketplace-order-shippings.ts

@@ -1,43 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const marketplaceOrderShippingsResolver = {
-  async marketplaceOrderShippings(_: any, params: ListParam, context: ResolverContext) {
-    let dateFilter = params.filters.filter(filter => filter.name == 'createdAt')
-
-    params.filters = params.filters.filter(x => x.name != 'createdAt')
-
-    const qb: SelectQueryBuilder<MarketplaceOrderShipping> = getRepository(MarketplaceOrderShipping)
-      .createQueryBuilder('MOS')
-      .innerJoinAndSelect('MOS.marketplaceOrderShippingItems', 'MOSI')
-      .innerJoinAndSelect('MOSI.marketplaceOrderItem', 'MOI')
-      .innerJoinAndSelect('MOI.marketplaceOrder', 'MO')
-      .innerJoinAndSelect('MOI.marketplaceProductVariation', 'MPV')
-      .innerJoinAndSelect('MOS.marketplaceStore', 'MS')
-      .innerJoinAndSelect('MOS.domain', 'domain')
-      .leftJoinAndSelect('MOS.creator', 'creator')
-      .leftJoinAndSelect('MOS.updater', 'updater')
-
-    buildQuery(qb, params, context, false)
-
-    if (dateFilter) {
-      if (dateFilter[0].operator == 'between') {
-        qb.andWhere('MO.orderCreatedAt BETWEEN :begin AND :end', {
-          begin: dateFilter[0].value[0],
-          end: dateFilter[0].value[1]
-        })
-      } else if (dateFilter[0].operator == 'gte') {
-        qb.andWhere('MO.orderCreatedAt >= :begin', { begin: dateFilter[0].value })
-      } else if (dateFilter[0].operator == 'lte') {
-        qb.andWhere('MO.orderCreatedAt <= :begin', { begin: dateFilter[0].value })
-      }
-    }
-
-    const [items, total] = await qb.getManyAndCount()
-
-    return { items, total }
-  }
-}