@things-factory/operato-hub 5.0.13 → 6.0.0-alpha.1

package/server/graphql/resolvers/synchronization/auto-update-all-marketplace-product-variation-quantity.ts

@@ -0,0 +1,180 @@
+import { getConnection, getRepository } from 'typeorm'
+
+import { logger } from '@things-factory/env'
+import { FulfillmentAPI } from '@things-factory/integration-fulfillment'
+import { MarketplaceSetting, MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { MarketplaceProductVariation } from '@things-factory/marketplace-base'
+import { Product, ProductDetail } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+import { getProductBundleInventory, Inventory, INVENTORY_STATUS, LOCATION_TYPE } from '@things-factory/warehouse-base'
+
+export const autoUpdateAllMarketplaceProductVariationQuantityResolver = {
+  async autoUpdateAllMarketplaceProductVariationQuantity(_: any, { companyDomainId, warehouseId }, context: any) {
+    const companyDomain: Domain = await getRepository(Domain).findOne(companyDomainId)
+
+    const marketplaceStores: MarketplaceStore[] = await getRepository(MarketplaceStore).find({
+      where: { domain: companyDomain, status: 'ACTIVE' },
+      relations: ['marketplaceDistributors']
+    })
+
+    const fulfilmentCenter = await FulfillmentAPI.getFulfillmentCenter(warehouseId)
+    const centerId: string = fulfilmentCenter.centerId
+    const warehouseDomain: Domain = await getRepository(Domain).findOne({ where: { subdomain: centerId } })
+
+    let products: Product[] = await getRepository(Product).find({
+      where: { domain: companyDomain },
+      relations: ['productDetails']
+    })
+
+    let inventoryProducts: any[] = await Promise.all(
+      products.map(async product => {
+        const productDetails: ProductDetail[] = product.productDetails
+        const defaultProductDetail: ProductDetail = productDetails.filter(productDetail => productDetail.isDefault)[0]
+
+        let qb = await getRepository(Inventory).createQueryBuilder('inv')
+        qb.leftJoinAndSelect('inv.location', 'loc')
+          .andWhere('"inv"."domain_id" = :domainId')
+          .andWhere('"inv"."product_id" = :productId')
+          .andWhere('"inv"."status" != :status')
+          .andWhere('"loc"."type" NOT IN (:...locationTypes)')
+          .setParameters({
+            domainId: warehouseDomain.id,
+            productId: product.id,
+            status: INVENTORY_STATUS.TERMINATED,
+            locationTypes: [LOCATION_TYPE.QUARANTINE, LOCATION_TYPE.RESERVE]
+          })
+
+        let inventories: Inventory[] = await qb.getMany()
+
+        const inventoryQty: number = inventories.reduce((total, currentValue) => {
+          total += currentValue.qty
+          return total
+        }, 0)
+
+        const inventoryLockedQty: number = inventories.reduce((total, currentValue) => {
+          total += currentValue.lockedQty
+          return total
+        }, 0)
+
+        return {
+          product,
+          sku: product.sku,
+          name: product.name,
+          packingType: defaultProductDetail.packingType,
+          packingSize: defaultProductDetail.packingSize,
+          uom: defaultProductDetail.uom,
+          qty: inventoryQty - inventoryLockedQty
+        }
+      })
+    )
+
+    await getConnection().transaction(async tx => {
+      let bundleProductInventories: any[] = await getProductBundleInventory(
+        warehouseDomain,
+        companyDomain,
+        inventoryProducts,
+        tx
+      )
+
+      bundleProductInventories.map(bundleProductInventory => {
+        inventoryProducts.push(bundleProductInventory)
+      })
+    })
+
+    for (let i = 0; i < marketplaceStores.length; i++) {
+      try {
+        const marketplaceStore: MarketplaceStore = marketplaceStores[i]
+
+        const marketplaceSetting: MarketplaceSetting = await getRepository(MarketplaceSetting).findOne({
+          where: { marketplaceStore, category: 'stock_allocation' }
+        })
+
+        for (let j = 0; j < inventoryProducts.length; j++) {
+          try {
+            await getConnection().transaction(async tx => {
+              const inventoryProduct = inventoryProducts[j]
+              const marketplaceProductVariations: MarketplaceProductVariation[] = await tx
+                .getRepository(MarketplaceProductVariation)
+                .find({
+                  where: { domain: companyDomain, sku: inventoryProduct.sku },
+                  relations: ['marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+                })
+
+              let storeProductVariations: MarketplaceProductVariation[] = marketplaceProductVariations.filter(
+                productVariation => productVariation.marketplaceProduct.marketplaceStore.id === marketplaceStore.id
+              )
+
+              let percentageValue: number = 100
+              if (storeProductVariations) {
+                for (let k = 0; k < storeProductVariations.length; k++) {
+                  let storeProductVariation: MarketplaceProductVariation = storeProductVariations[k]
+                  if (marketplaceSetting) {
+                    percentageValue = parseInt(marketplaceSetting.value)
+                  }
+
+                  let remainQty: number = Math.floor(
+                    (inventoryProduct.qty - storeProductVariation.reserveQty) * (percentageValue / 100)
+                  )
+                  if (remainQty < 0) remainQty = 0
+
+                  let productVariationLocationId = storeProductVariation?.locationId
+                  let adjustQty: number = remainQty
+
+                  if (marketplaceStore.platform === 'shopify') {
+                    let locationIds: any[] = JSON.parse(productVariationLocationId)
+                    adjustQty = adjustQty - storeProductVariation.qty
+                    if (locationIds[0]?.location_id) productVariationLocationId = locationIds[0].location_id
+                  }
+
+                  let validMarketplaceDistributors: any[] = []
+                  if (marketplaceStore.marketplaceDistributors) {
+                    validMarketplaceDistributors = marketplaceStore.marketplaceDistributors.filter(
+                      distributor => distributor.status === 'ACTIVE'
+                    )
+                  }
+
+                  const hasVariation: boolean = storeProductVariation?.marketplaceProduct?.hasVariation
+
+                  if (hasVariation) {
+                    await StoreAPI.updateStoreProductVariationStock(marketplaceStore, [
+                      {
+                        itemId: storeProductVariation.marketplaceProduct.itemId,
+                        variationId: storeProductVariation.variationId,
+                        variationSku: storeProductVariation.variationSku,
+                        qty: adjustQty,
+                        locationId: productVariationLocationId,
+                        inventoryItemId: storeProductVariation.inventoryItemId,
+                        distributors: validMarketplaceDistributors
+                      }
+                    ])
+                  } else {
+                    await StoreAPI.updateStoreProductStock(marketplaceStore, [
+                      {
+                        itemId: storeProductVariation.marketplaceProduct.itemId,
+                        variationId: storeProductVariation.variationId,
+                        variationSku: storeProductVariation.variationSku,
+                        qty: adjustQty,
+                        distributors: validMarketplaceDistributors
+                      }
+                    ])
+                  }
+
+                  storeProductVariation.qty = remainQty
+                  await tx.getRepository(MarketplaceProductVariation).save(storeProductVariation)
+                }
+              }
+            })
+          } catch (error) {
+            logger.error(
+              `interface-with-hub[autoUpdateAllMarketplaceProductVariationQuantity]inventoryProducts: ${error}`
+            )
+          }
+        }
+      } catch (e) {
+        logger.error(`interface-with-hub[autoUpdateAllMarketplaceProductVariationQuantity]marketplaceStores: ${e}`)
+      }
+    }
+
+    return true
+  }
+}

package/server/graphql/resolvers/synchronization/create-dat-shipments.ts

@@ -0,0 +1,64 @@
+import { getConnection, MoreThan } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { Sftp, SftpAPI } from '@things-factory/integration-sftp'
+import { ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+export const createDatShipments = {
+  async createDatShipments(_: void, {}, context: ResolverContext): Promise<void> {
+    try {
+      await getConnection().transaction(async tx => {
+        const currentTime = new Date()
+        const batchSize = 80
+        let sftps: Sftp[] = await tx.getRepository(Sftp).find({
+          where: { status: 'ACTIVE' },
+          relations: ['domain', 'fulfillmentCenter']
+        })
+
+        for (let sftp of sftps) {
+          let warehouseDomain: Domain = await tx.getRepository(Domain).findOne({
+            where: { subdomain: sftp.fulfillmentCenter.centerId }
+          })
+
+          let bizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+            where: { domain: sftp.domain }
+          })
+
+          let releaseGoods: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
+            where: {
+              domain: warehouseDomain,
+              bizplace: bizplace,
+              status: 'DONE',
+              updatedAt: MoreThan(sftp.lastTimeSync)
+            },
+            relations: ['orderInventories', 'orderInventories.product']
+          })
+
+          while (releaseGoods.length > 0) {
+            let releaseGoodBatch = releaseGoods.splice(
+              0,
+              releaseGoods.length >= batchSize ? batchSize : releaseGoods.length
+            )
+
+            const responseFileTypes: any = JSON.parse(sftp.responseFileTypes)
+
+            if (releaseGoodBatch.length > 0) {
+              if (responseFileTypes.enableShipment) {
+                let shipmentResult: Sftp = await SftpAPI.createShipment(sftp, {
+                  releaseGoods: releaseGoodBatch,
+                  sftp: sftp
+                })
+                shipmentResult.lastTimeSync = currentTime
+                sftp = await tx.getRepository(Sftp).save(shipmentResult)
+              }
+            }
+          }
+        }
+      })
+    } catch (e) {
+      logger.error(`createDatShipment: ${e}`)
+    }
+  }
+}

package/server/graphql/resolvers/synchronization/fetch-sync-products.ts

@@ -1,7 +1,8 @@
 import { Bizplace } from '@things-factory/biz-base'
 import { AccountingAPI } from '@things-factory/integration-accounting'
 import { Product } from '@things-factory/product-base'
-import { getRepository } from 'typeorm'
+import { getRepository } from '@things-factory/shell'
+
 import { buildMap } from '../../../utils/build-map'
 
 export const fetchSyncProductsResolver = {
@@ -18,7 +19,7 @@ export const fetchSyncProductsResolver = {
       const platformProducts: Product[] = await getAccountingProducts(accountId)
       const platformProductsMap: Map<string, Product> = buildMap(platformProducts, 'sku')
 
-      const bizplace: Bizplace = await getRepository(Bizplace).findOne(bizplaceId)
+      const bizplace: Bizplace = await getRepository(Bizplace).findOneBy({ id: bizplaceId })
       const bizplaceProducts: Product[] = await getRepository(Product).find({ where: { bizplace } })
       const bizplaceProductsMap: Map<string, Product> = buildMap(bizplaceProducts, 'sku')
 

package/server/graphql/resolvers/synchronization/index.ts

@@ -1,9 +1,13 @@
+import { fetchSyncInvoicesResolver } from './fetch-sync-invoices'
 import { fetchSyncProductsResolver } from './fetch-sync-products'
 import { fetchSyncPurchaseOrdersResolver } from './fetch-sync-purchase-orders'
-import { fetchSyncInvoicesResolver } from './fetch-sync-invoices'
+import { sellercraftPackMarketplaceOrderResolver } from './sellercraft-pack-marketplace-order'
+import { syncAllProductsToSellercraftResolver } from './sync-all-products-to-sellercraft'
 import { syncProductsFromAccountResolver } from './sync-products-from-account'
 import { syncProductsToAccountResolver } from './sync-products-to-account'
 import { syncProductsToSellercraftResolver } from './sync-products-to-sellercraft'
+import { createDatShipments } from './create-dat-shipments'
+import { autoUpdateAllMarketplaceProductVariationQuantityResolver } from './auto-update-all-marketplace-product-variation-quantity'
 
 export const Query = {
   ...fetchSyncProductsResolver,
@@ -14,5 +18,9 @@ export const Query = {
 export const Mutation = {
   ...syncProductsToSellercraftResolver,
   ...syncProductsFromAccountResolver,
-  ...syncProductsToAccountResolver
+  ...syncProductsToAccountResolver,
+  ...syncAllProductsToSellercraftResolver,
+  ...sellercraftPackMarketplaceOrderResolver,
+  ...createDatShipments,
+  ...autoUpdateAllMarketplaceProductVariationQuantityResolver
 }

package/server/graphql/resolvers/synchronization/sellercraft-pack-marketplace-order.ts

@@ -0,0 +1,91 @@
+import { getConnection, In, IsNull, Not, Repository } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
+import { Sellercraft, SellercraftAPI, SellercraftStatus } from '@things-factory/integration-sellercraft'
+import { Product } from '@things-factory/product-base'
+import { ORDER_STATUS, OrderProduct, ReleaseGood } from '@things-factory/sales-base'
+import { Domain } from '@things-factory/shell'
+
+export const sellercraftPackMarketplaceOrderResolver = {
+  async sellercraftPackMarketplaceOrder(_: void, {}, context: ResolverContext): Promise<void> {
+    try {
+      await getConnection().transaction(async tx => {
+        const sellercrafts: Sellercraft[] = await tx
+          .getRepository(Sellercraft)
+          .find({ where: { status: SellercraftStatus.ACTIVE }, relations: ['domain'] })
+
+        for (const sellercraft of sellercrafts) {
+          try {
+            const sellercraftDomain: Domain = sellercraft.domain
+            const bizplace: Bizplace = await tx
+              .getRepository(Bizplace)
+              .findOne({ where: { domain: sellercraftDomain } })
+
+            let releaseGoodsWithoutPackageId: ReleaseGood[] = await tx.getRepository(ReleaseGood).find({
+              where: {
+                bizplace,
+                type: 'b2c',
+                packageId: IsNull(),
+                status: Not(In([ORDER_STATUS.CANCELLED, ORDER_STATUS.PENDING_CANCEL, ORDER_STATUS.DONE]))
+              },
+              relations: ['domain', 'orderProducts', 'orderProducts.product']
+            })
+
+            if (releaseGoodsWithoutPackageId?.length > 0) {
+              await Promise.all(
+                releaseGoodsWithoutPackageId.map(async releaseGood => {
+                  const orderProducts: OrderProduct[] = releaseGood.orderProducts
+                  let sellercraftOPs: any[] = []
+
+                  sellercraftOPs = orderProducts.map(orderProduct => {
+                    const product: Product = orderProduct.product
+
+                    return {
+                      sku: product.sku,
+                      releaseQty: orderProduct.releaseQty,
+                      uom: 'EA'
+                    }
+                  })
+
+                  const orderInformation: any = {
+                    accountId: sellercraft.accountId,
+                    orderId: releaseGood.refNo2,
+                    sellercraftOPs
+                  }
+
+                  const packageId: string = await SellercraftAPI.packMarketplaceOrder(sellercraft, {
+                    ...orderInformation,
+                    context: { state: { domain: releaseGood?.domain, user: null } }
+                  })
+
+                  createPayloadLog(
+                    sellercraft.accountId,
+                    `/order/pack`,
+                    orderInformation,
+                    packageId,
+                    context,
+                    PayloadType.EGESTION,
+                    'scheduler'
+                  )
+
+                  if (packageId) {
+                    await (tx.getRepository(ReleaseGood) as Repository<ReleaseGood>).update(
+                      { id: releaseGood.id },
+                      { packageId: packageId }
+                    )
+                  }
+                })
+              )
+            }
+          } catch (e) {
+            logger.error(`sellercraftPackMarketplaceOrder: ${e}`)
+          }
+        }
+      })
+    } catch (e) {
+      logger.error(`sellercraftPackMarketplaceOrder: ${e}`)
+    }
+  }
+}

package/server/graphql/resolvers/synchronization/sync-all-products-to-sellercraft.ts

@@ -0,0 +1,39 @@
+import { getConnection } from 'typeorm'
+
+import { Bizplace, getCompanyBizplace } from '@things-factory/biz-base'
+import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { Sellercraft } from '@things-factory/integration-sellercraft'
+
+import { syncProductsToSellercraftResolver as resolver } from './sync-products-to-sellercraft'
+
+export const syncAllProductsToSellercraftResolver = {
+  async syncAllProductsToSellercraft(_: any, {}, context: ResolverContext): Promise<void> {
+    const { user } = context.state
+    try {
+      await getConnection().transaction(async tx => {
+        const qb = await tx
+          .getRepository(Sellercraft)
+          .createQueryBuilder('sellercraft')
+          .innerJoinAndSelect('sellercraft.domain', 'domain')
+          .innerJoinAndSelect(Bizplace, 'bizplace', 'bizplace.domain_id = domain.id')
+          .where('sellercraft.status = :status', { status: 'ACTIVE' })
+
+        const sellercrafts: Sellercraft[] = await qb.getRawMany()
+
+        for (const sellercraft of sellercrafts) {
+          const companyBizplace: Bizplace = await getCompanyBizplace(null, null, sellercraft.bizplace_id, tx)
+          const fulfillmentCenter: FulfillmentCenter = await tx.getRepository(FulfillmentCenter).find({
+            where: { domain: companyBizplace.domain }
+          })
+          await resolver.syncProductsToSellercraft(
+            null,
+            { sellercraftId: sellercraft.id, fulfillmentCenterId: fulfillmentCenter.id, toCreateSku: false },
+            context
+          )
+        }
+      })
+    } catch (e) {
+      console.log(e)
+    }
+  }
+}

package/server/graphql/resolvers/synchronization/sync-products-from-account.ts

@@ -1,6 +1,6 @@
 import { Bizplace } from '@things-factory/biz-base'
 import { Product } from '@things-factory/product-base'
-import { EntityManager } from 'typeorm'
+
 import { buildMap } from '../../../utils/build-map'
 import { getAccountingProducts } from './fetch-sync-products'
 
@@ -8,12 +8,12 @@ export const syncProductsFromAccountResolver = {
   async syncProductsFromAccount(
     _: void,
     { accountId, bizplaceId }: { accountId: string; bizplaceId: string },
-    context: any
+    context: ResolverContext
   ): Promise<void> {
     try {
-      const { tx }: { tx: EntityManager } = context.state
+      const { tx } = context.state
       let platformProducts: Product[] = await getAccountingProducts(accountId)
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: bizplaceId })
       const platformProductsMap: Map<string, Product> = buildMap(platformProducts, 'sku')
 
       let bizplaceProducts: Product[] = await tx.getRepository(Product).find({ where: { bizplace } })

package/server/graphql/resolvers/synchronization/sync-products-to-account.ts

@@ -1,7 +1,7 @@
 import { Bizplace } from '@things-factory/biz-base'
 import { AccountingAPI } from '@things-factory/integration-accounting'
 import { Product } from '@things-factory/product-base'
-import { EntityManager } from 'typeorm'
+
 import { buildMap } from '../../../utils/build-map'
 import { getAccountingProducts } from './fetch-sync-products'
 
@@ -9,12 +9,12 @@ export const syncProductsToAccountResolver = {
   async syncProductsToAccount(
     _: void,
     { accountId, bizplaceId }: { accountId: string; bizplaceId: string },
-    context: any
+    context: ResolverContext
   ): Promise<void> {
     try {
-      const { tx }: { tx: EntityManager } = context.state
+      const { tx } = context.state
 
-      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOne(bizplaceId)
+      const bizplace: Bizplace = await tx.getRepository(Bizplace).findOneBy({ id: bizplaceId })
       const bizplaceProducts: Product[] = await tx.getRepository(Product).find({ where: { bizplace } })
 
       let platformProducts: Product[] = await getAccountingProducts(accountId)

package/server/graphql/resolvers/synchronization/sync-products-to-sellercraft.ts

@@ -1,11 +1,8 @@
-import { EntityManager, getRepository } from 'typeorm'
-
 import { Bizplace } from '@things-factory/biz-base'
 import { logger } from '@things-factory/env'
 import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
 import { Sellercraft, SellercraftAPI } from '@things-factory/integration-sellercraft'
-import { Product, ProductDetail } from '@things-factory/product-base'
-import { WarehouseBizplaceOnhandInventory } from '@things-factory/worksheet-base'
+import { ProductDetail } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
 export const syncProductsToSellercraftResolver = {
@@ -18,18 +15,21 @@ export const syncProductsToSellercraftResolver = {
     context: any
   ): Promise<void> {
     try {
-      const { domain, tx }: { domain: Domain; tx: EntityManager } = context.state
+      const { domain, tx } = context.state
 
       let page: number = 0
       let hasMorePage: boolean = true
       const limit: number = 50
 
-      const sellercraft: Sellercraft = await tx.getRepository(Sellercraft).findOne({ where: { id: sellercraftId }, relations: ['domain'] })
+      const sellercraft: Sellercraft = await tx
+        .getRepository(Sellercraft)
+        .findOne({ where: { id: sellercraftId }, relations: ['domain'] })
       const customerDomain: Domain = sellercraft.domain
       const fulfilmentCenter: FulfillmentCenter = await FulfillmentAPI.getFulfillmentCenter(fulfillmentCenterId)
       const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({ where: { domain: customerDomain } })
 
-      await tx.query(`
+      await tx.query(
+        `
         create temp table temp_warehouse_product_inventory ON COMMIT DROP as (
           select p.id, p.sku as product_sku, p.name as product_name, p.description as product_description, 
           pd.gtin, pd.uom, pd.packing_size, coalesce(pd.nett_weight, 0) as nett_weight, pd.width, pd."depth", pd.height,
@@ -51,7 +51,9 @@ export const syncProductsToSellercraftResolver = {
             and src."uom" = pd."uom" 
           where b.id = $2
         )
-      `, [fulfilmentCenter.id, customerBizplace.id])
+      `,
+        [fulfilmentCenter.id, customerBizplace.id]
+      )
 
       let total = await tx.query(`
         select count(*) from temp_warehouse_product_inventory            
@@ -66,9 +68,12 @@ export const syncProductsToSellercraftResolver = {
           //   paginationOffset: page
           // })
 
-          const items = await tx.query(`
+          const items = await tx.query(
+            `
             select * from temp_warehouse_product_inventory limit $1 offset $2
-          `, [limit, page * limit])
+          `,
+            [limit, page * limit]
+          )
 
           let sellercraftInv: any[] = []
 
@@ -101,9 +106,11 @@ export const syncProductsToSellercraftResolver = {
           await SellercraftAPI.updateProduct(sellercraft, { context, accountId: sellercraft.accountId, sellercraftInv })
 
           page++
-          hasMorePage = (total[0]?.count || 0) > (page * limit)
+          hasMorePage = (total[0]?.count || 0) > page * limit
         } catch (e) {
-          logger.error(`[syncProductsToSellercraftResolver] sellercraftID:${sellercraftId} fulfillmentCenterId:${fulfillmentCenterId} page:${page} - ${e}`)
+          logger.error(
+            `[syncProductsToSellercraftResolver] sellercraftID:${sellercraftId} fulfillmentCenterId:${fulfillmentCenterId} page:${page} - ${e}`
+          )
         }
       }
     } catch (e) {

package/server/graphql/types/synchronization/index.ts

@@ -15,6 +15,10 @@ export const Mutation = /* GraphQL */ `
   syncProductsToSellercraft(sellercraftId: String!, fulfillmentCenterId: String!): Boolean @transaction
   syncProductsFromAccount(accountId: String!, bizplaceId: String!): Boolean @transaction
   syncProductsToAccount(accountId: String!, bizplaceId: String!): Boolean @transaction
+  syncAllProductsToSellercraft: Boolean @transaction
+  sellercraftPackMarketplaceOrder: Boolean @transaction
+  createDatShipments: Boolean @transaction
+  autoUpdateAllMarketplaceProductVariationQuantity(companyDomainId: String, warehouseId: String): Boolean @transaction
 `
 
 export const Types = [

package/server/index.ts

@@ -1,13 +1,13 @@
-export * from './graphql'
-export * from './middlewares'
-export * from './migrations'
+import './routers/api'
+import './routes'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace } from '@things-factory/biz-base'
-import { Domain } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
-import './routers/api'
-import './routes'
+import { Domain, getRepository } from '@things-factory/shell'
+
+export * from './graphql'
+export * from './middlewares'
+export * from './migrations'
 
 declare global {
   namespace NodeJS {

package/server/middlewares/business-middleware.ts

@@ -1,6 +1,5 @@
 import { Bizplace, Company } from '@things-factory/biz-base'
-import { Domain, getDomainFromURL } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
+import { Domain, getDomainFromURL, getRepository } from '@things-factory/shell'
 
 const debug = require('debug')('things-factory:operato-hub:business-middleware')
 

package/server/middlewares/store-middleware.ts

@@ -1,5 +1,5 @@
-import { getRepository } from 'typeorm'
 import { MarketplaceStore as MarketplaceStoreEntity } from '@things-factory/integration-marketplace'
+import { getRepository } from '@things-factory/shell'
 
 const debug = require('debug')('things-factory:operato-hub:store-middleware')
 

package/server/middlewares/warehouse-middleware.ts

@@ -1,5 +1,5 @@
-import { getRepository } from 'typeorm'
 import { Bizplace } from '@things-factory/biz-base'
+import { getRepository } from '@things-factory/shell'
 
 const debug = require('debug')('things-factory:operato-hub:warehouse-middleware')
 
@@ -17,7 +17,8 @@ export async function warehouseMiddleware(context, next) {
   }
 
   if (warehouseId) {
-    warehouse = await getRepository(Bizplace).findOne(warehouseId, {
+    warehouse = await getRepository(Bizplace).findOne({
+      where: { id: warehouseId },
       relations: ['company', 'domain']
     })
     debug('warehouse', warehouseId, warehouse?.domain?.subdomain)

package/server/migrations/1597668478399-SeedBusinessDomain.ts

@@ -1,5 +1,6 @@
-import { MigrationInterface, QueryRunner, getRepository } from 'typeorm'
-import { Domain } from '@things-factory/shell'
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+import { Domain, getRepository } from '@things-factory/shell'
 
 const SEED_BUSINESS_DOMAIN = [
   {

package/server/migrations/1597668478401-SeedBusinessRoles.ts

@@ -351,7 +351,7 @@ export class SeedBusinessRoles1597668478401 implements MigrationInterface {
     //     const privileges = await Promise.all(
     //       role.privileges.map(
     //         async privilege =>
-    //           await privilegeRepo.findOne({
+    //           await privilegeRepo.findOneBy({
     //             ...privilege
     //           })
     //       )
@@ -367,7 +367,7 @@ export class SeedBusinessRoles1597668478401 implements MigrationInterface {
   public async down(queryRunner: QueryRunner): Promise<any> {
     // const roleRepo = getRepository(Role)
     // const domainRepo = getRepository(Domain)
-    // const domain = await domainRepo.findOne({ where: })
+    // const domain = await domainRepo.findOne({ where: ...})
     // return await Promise.all(
     //   SEED_ROLES_PRIVILEGES.reverse().map(async (role: Role) => {
     //     await roleRepo.delete({ domain, name: role.name })