@things-factory/integration-marketplace 8.0.6 → 9.0.0-beta.12

package/server/controllers/shopify/apis/get-store-product-categories.ts

@@ -1,19 +0,0 @@
-/* https://open.shopee.com/documents?module=2&type=1&id=373 */
-
-export function getStoreProductCategories() {
-  return {
-    path: '/item/categories/get',
-    denormalize(req) {
-      var { pagination } = req || {}
-      var { page = 0, limit = 100 } = pagination || {}
-
-      return {
-        pagination_entries_per_page: limit,
-        pagination_offset: page
-      }
-    },
-    normalize(res) {
-      return res.categories
-    }
-  }
-}

package/server/controllers/shopify/apis/get-store-product-category-attributes.ts

@@ -1,18 +0,0 @@
-/* https://open.shopee.com/documents?module=2&type=1&id=372 */
-
-export function getStoreProductCategoryAttributes() {
-  return {
-    path: '/item/attributes/get',
-    denormalize(req) {
-      var { categoryId, isCrossBorder = true } = req
-
-      return {
-        category_id: categoryId,
-        is_cb: isCrossBorder
-      }
-    },
-    normalize(res) {
-      return res.attributes
-    }
-  }
-}

package/server/controllers/shopify/apis/get-store-product-variation-stock.ts

@@ -1,17 +0,0 @@
-export function getStoreProductVariationStock() {
-  return {
-    path: '/variants/{variantId}.json',
-    method: 'get',
-    denormalize(req) {
-      let { variantId } = req
-      return {
-        resource: {
-          variantId
-        }
-      }
-    },
-    normalize(res) {
-      return res?.variant?.inventory_quantity
-    }
-  }
-}

package/server/controllers/shopify/apis/get-store-products-count.ts

@@ -1,14 +0,0 @@
-/* https://shopify.dev/docs/admin-api/rest/reference/products/product?api[version]=2020-01#index-2020-01 */
-
-export function getStoreProductsCount() {
-  return {
-    method: 'get',
-    path: '/products/count.json',
-    denormalize(req) {
-      return {}
-    },
-    async normalize(res, { store }) {
-      return res.count
-    }
-  }
-}

package/server/controllers/shopify/apis/get-store-products.ts

@@ -1,177 +0,0 @@
-/* https://shopify.dev/docs/admin-api/rest/reference/products/product?api[version]=2020-07#index-2020-07 */
-
-import { URL } from 'url'
-
-import { StoreAPI } from '../../store-api'
-
-export function getStoreProducts() {
-  return {
-    method: 'get',
-    path: '/products.json',
-    denormalize(req) {
-      var { pagination, pageInfo, fromUpdatedDate, toUpdatedDate } = req || {}
-      var { page, limit } = pagination || { page: 0, limit: 100 }
-
-      var payload: any = {
-        limit: limit
-      }
-
-      if (fromUpdatedDate && toUpdatedDate) {
-        payload.updated_at_max = toUpdatedDate
-        payload.updated_at_min = fromUpdatedDate
-      }
-
-      if (pageInfo) payload.page_info = pageInfo
-
-      return { payload }
-    },
-    async normalize(res, { store }) {
-      // return res.products
-      const linkParams = res.link
-      let page_info: string
-
-      if (linkParams) {
-        const url = extractLinkParams(linkParams)
-        var urlParams = new URL(url)
-        page_info = urlParams.searchParams.get('page_info')
-      }
-
-      let results: any[] = []
-      let totalProducts = await StoreAPI.getStoreProductsCount(store, res)
-
-      for (var i = 0; i < res.products.length; i++) {
-        const product: any = res.products[i]
-        const productVariations: any[] = product.variants
-
-        const inventoryIds: string[] = productVariations.map(productVariation => productVariation.inventory_item_id)
-        const inventoryItemIds: string = inventoryIds.join()
-
-        const inventoryLevels: any = await StoreAPI.getInventoryLevel(store, {
-          inventoryItemIds
-        })
-
-        for (var j = 0; j < productVariations.length; j++) {
-          let locationIds: any = []
-          const productVariation: any = productVariations[j]
-          const productInventoryItemId = productVariation.inventory_item_id
-          for (var k = 0; k < inventoryLevels.inventory_levels.length; k++) {
-            const inventoryLevel: any = inventoryLevels.inventory_levels[k]
-            const inventoryItemId = inventoryLevel.inventory_item_id
-
-            if (inventoryItemId == productInventoryItemId) {
-              const locationId: any = {
-                location_id: inventoryLevel.location_id,
-                available: inventoryLevel.available === null ? 0 : inventoryLevel.available
-              }
-              locationIds.push(locationId)
-            }
-          }
-          productVariation.location_id = JSON.stringify(locationIds)
-        }
-
-        const result = {
-          itemId: product.id,
-          name: product.title,
-          type: product.product_type,
-          description: product.body_html,
-          marketplaceStatus: product.status,
-          hasVariation: true,
-          categoryId: product?.collection_id ? product.collection_id : null,
-          attributes: [],
-          sellercraftAttributes: [
-            {
-              native_attribute_id: 'description',
-              attribute_key: 'description',
-              display_name: 'Description',
-              values: [product.body_html],
-              data_type: 'RICH_TEXT'
-            }
-          ],
-          images: product?.images?.map(image => {
-            return image.src
-          }) || [],
-          variations: productVariations.map(variant => {
-            return {
-              variationId: variant.id,
-              variationSku: variant.sku,
-              channelSku: variant.sku,
-              name: variant.title == 'Default Title' ? product.title : variant.title,
-              qty: variant.inventory_quantity,
-              inventoryPolicy: variant.inventory_policy,
-              inventoryItemId: variant.inventory_item_id,
-              locationId: variant.location_id,
-              extraMetadata: {
-                inventoryItemId: variant.inventory_item_id,
-                locationId: variant.location_id,  
-              },
-              primaryUnit: variant.weight_unit,
-              primaryUnitValue: variant.weight,
-              costPrice: variant.price,
-              sellPrice: variant.compare_at_price || variant.price,
-              attributes: [
-                {
-                  attributeId: variant.option1,
-                  name: variant.option1
-                },
-                {
-                  attributeId: variant.option2,
-                  name: variant.option2
-                },
-                {
-                  attributeId: variant.option3,
-                  name: variant.option3
-                }
-              ],
-              sellercraftAttributes: product?.options.map(option => {
-                return {
-                  native_attribute_id: option.name,
-                  attribute_key: option.name,
-                  display_name: option.name,
-                  values: [variant[`option${option.position}`]]
-                }
-              }) || [],
-              weight: variant.grams,
-              presentmentPrices: variant?.presentment_prices
-                ? variant.presentment_prices.map(presentmentPrice => {
-                    return {
-                      currency: presentmentPrice.price?.currency_code
-                        ? presentmentPrice.price.currency_code
-                        : presentmentPrice.compare_at_price.currency_code,
-                      costPrice: presentmentPrice.compare_at_price?.amount
-                        ? presentmentPrice.compare_at_price.amount
-                        : presentmentPrice.price.amount,
-                      sellPrice: presentmentPrice.price?.amount
-                        ? presentmentPrice.price.amount
-                        : presentmentPrice.compare_at_price.amount
-                    }
-                  })
-                : {
-                    currency: null,
-                    costPrice: variant.price,
-                    sellPrice: variant.compare_at_price
-                  }
-            }
-          })
-        }
-
-        results.push({ ...result })
-      }
-
-      return { results, total: totalProducts, page_info }
-    }
-  }
-}
-
-function extractLinkParams(link) {
-  let nextLink = link
-
-  // If there's a previous link, remove the first part of the string entirely
-  if (nextLink.indexOf(`rel="previous"`) > -1) {
-    nextLink = nextLink.substr(nextLink.indexOf(',') + 2, nextLink.length)
-  }
-
-  // Parse the remaining string for the actual link
-  nextLink = nextLink.substr(1, nextLink.indexOf('>') - 1)
-
-  return nextLink
-}

package/server/controllers/shopify/apis/index.ts

@@ -1,13 +0,0 @@
-export * from './echo'
-export * from './get-store-products'
-export * from './get-store-products-count'
-export * from './get-store-orders'
-export * from './get-inventory-level'
-export * from './update-store-product-variation-stock'
-export * from './update-order-status'
-export * from './set-store-order-status-ready-to-ship'
-export * from './get-store-order'
-export * from './update-store-product-variation-price'
-export * from './update-store-product-price'
-export * from './update-store-product-stock'
-export * from './get-store-product-variation-stock'

package/server/controllers/shopify/apis/set-store-order-status-ready-to-ship.ts

@@ -1,31 +0,0 @@
-/* https://shopify.dev/api/admin-rest/2021-10/resources/fulfillment#[post]/admin/api/2021-10/fulfillments.json */
-
-export function setStoreOrderStatusReadyToShip() {
-  return {
-    method: 'post',
-    path: '/orders/{orderId}/fulfillments.json',
-    denormalize(req) {
-      const { orderId, trackingUrl, trackingNo, orderItemId, order, transporter } = req || {}
-
-      let locationId = JSON.parse(order.marketplaceOrderItems[0].marketplaceProductVariation.locationId)[0].location_id
-
-      return {
-        payload: {
-          fulfillment: {
-            location_id: locationId,
-            tracking_number: trackingNo,
-            tracking_urls: [trackingUrl],
-            notify_customer: true,
-            tracking_company: transporter
-          }
-        },
-        resource: {
-          orderId
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/apis/update-order-status.ts

@@ -1,32 +0,0 @@
-/* https://shopify.dev/api/admin-rest/2021-10/resources/fulfillment#[post]/admin/api/2021-10/fulfillments.json */
-
-export function updateOrderStatus() {
-  return {
-    method: 'post',
-    path: '/orders/{orderId}/fulfillments.json',
-    denormalize(req) {
-      const { orderId, trackingNo, locations, carrier, status } = req || {}
-
-      if (status != 'READY_TO_SHIP') {
-        throw new Error('Shopify cannot create fulfillment, order status is not READY_TO_SHIP')
-      }
-
-      return {
-        payload: {
-          fulfillment: {
-            location_id: locations[0],
-            tracking_number: trackingNo,
-            notify_customer: true,
-            tracking_company: carrier
-          }
-        },
-        resource: {
-          orderId
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/apis/update-store-product-price.ts

@@ -1,26 +0,0 @@
-/*https://shopify.dev/api/admin-rest/2021-10/resources/product-variant#put-variants-variant-id */
-
-export function updateStoreProductPrice() {
-  return {
-    path: '/variants/{variantId}.json',
-    method: 'put',
-    denormalize(req) {
-      let { costPrice, sellPrice, variationId } = req
-
-      return {
-        payload: {
-          variant: {
-            price: costPrice,
-            compare_at_price: sellPrice
-          }
-        },
-        resource: {
-          variantId: variationId
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/apis/update-store-product-stock.ts

@@ -1,20 +0,0 @@
-export function updateStoreProductStock() {
-  return {
-    method: 'post',
-    path: '/inventory_levels/adjust.json',
-    denormalize(req) {
-      const { inventoryItemId, locationId: location_id, qty } = (Array.isArray(req) ? req[0] : req) || {}
-
-      return {
-        payload: {
-          inventory_item_id: parseInt(inventoryItemId),
-          location_id,
-          available_adjustment: parseInt(qty)
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/apis/update-store-product-variation-price.ts

@@ -1,26 +0,0 @@
-/*https://shopify.dev/api/admin-rest/2021-10/resources/product-variant#put-variants-variant-id */
-
-export function updateStoreProductVariationPrice() {
-  return {
-    path: '/variants/{variantId}.json',
-    method: 'put',
-    denormalize(req) {
-      let { costPrice, sellPrice, variationId } = req
-
-      return {
-        payload: {
-          variant: {
-            price: costPrice,
-            compare_at_price: sellPrice
-          }
-        },
-        resource: {
-          variantId: variationId
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/apis/update-store-product-variation-stock.ts

@@ -1,20 +0,0 @@
-export function updateStoreProductVariationStock() {
-  return {
-    method: 'post',
-    path: '/inventory_levels/adjust.json',
-    denormalize(req) {
-      const { inventoryItemId, locationId: location_id, qty } = (Array.isArray(req) ? req[0] : req) || {}
-
-      return {
-        payload: {
-          inventory_item_id: parseInt(inventoryItemId),
-          location_id,
-          available_adjustment: parseInt(qty)
-        }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/shopify/index.ts

@@ -1,8 +0,0 @@
-export * from './shopify'
-
-import { StoreAPI } from '../store-api'
-
-import { action } from './platform-action'
-import * as APIS from './apis'
-
-StoreAPI.registerPlatform('shopify', action, APIS)

package/server/controllers/shopify/platform-action.ts

@@ -1,43 +0,0 @@
-import { Shopify } from './shopify'
-
-import { config } from '@things-factory/env'
-const shopifyConfig = config.get('marketplaceIntegrationShopify', {})
-const { apiKey, apiSecret } = shopifyConfig
-
-function substitute(path, obj) {
-  var props = []
-  var re = /{([^}]+)}/g
-  var text
-
-  while ((text = re.exec(path))) {
-    props.push(text[1])
-  }
-
-  var result = path
-  props.forEach(prop => {
-    let value = obj[prop.trim()]
-    result = result.replace(`{${prop}}`, value === undefined ? '' : value)
-  })
-
-  return result
-}
-
-export const action = async ({ store, method = 'get', path, request }) => {
-  const client = new Shopify({
-    shop: store.storeId,
-    apiKey,
-    apiSecret,
-    accessToken: store.accessToken
-  })
-
-  const { resource = {}, payload = {} } = request
-
-  path = substitute(path, resource)
-
-  var response = await client[method](path, payload)
-  if (response.errors) {
-    throw response
-  }
-
-  return response
-}

package/server/controllers/shopify/shopify.ts

@@ -1,148 +0,0 @@
-import fetch from 'node-fetch'
-import crypto from 'crypto'
-import { URLSearchParams } from 'url'
-
-import { createPayloadLog } from '@things-factory/integration-base'
-
-const debug = require('debug')('things-factory:integration-marketplace:shopify')
-
-export type ShopifyConfig = {
-  apiKey: string
-  apiSecret: string
-  shop: string
-  accessToken?: string
-}
-
-export class Shopify {
-  private config: ShopifyConfig
-
-  constructor(config: ShopifyConfig) {
-    this.config = {
-      ...config
-    }
-  }
-
-  makeVerificationTokenForNonce() {
-    return crypto.randomBytes(16).toString('hex')
-  }
-
-  buildAuthURL(redirectUrl, nonce) {
-    // regarding accessMode refer to https://shopify.dev/tutorials/authenticate-with-oauth#step-2-ask-for-permission
-    // and https://community.shopify.com/c/API-Announcements/Shopify-now-offers-two-types-of-API-access-tokens/td-p/315398
-    // so, accessMode should be 'offline'
-    // var accessMode = 'per-user'
-
-    // TODO make scopes properly
-    var scopes = 'read_products,write_orders,read_customers,read_inventory,write_inventory'
-
-    var { shop, apiKey } = this.config
-
-    // return `https://${shop}.myshopify.com/admin/oauth/authorize?client_id=${apiKey}&scope=${scopes}&redirect_uri=${redirectUrl}&state=${nonce}&grant_options[]=${accessMode}`
-    return `https://${shop}.myshopify.com/admin/oauth/authorize?client_id=${apiKey}&scope=${scopes}&redirect_uri=${redirectUrl}&state=${nonce}`
-  }
-
-  isValidSignature(query) {
-    const { apiSecret } = this.config
-    const { hmac, ...params } = query
-
-    const queryParams = new URLSearchParams(params).toString()
-
-    return hmac === crypto.createHmac('sha256', apiSecret).update(queryParams).digest('hex')
-  }
-
-  verifyWebhook(request, hmac: string, webhookKey) {
-    return hmac === crypto.createHmac('sha256', webhookKey).update(request.rawBody.toString()).digest('base64')
-  }
-
-  async get(path: string, data: any) {
-    const { shop, accessToken } = this.config
-
-    const qs = new URLSearchParams(data).toString()
-
-    const endpoint = `https://${shop}.myshopify.com/admin/api/2020-01${path}${qs ? '?' + qs : ''}`
-    debug('endpoint', endpoint)
-
-    const response = await fetch(endpoint, {
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Shopify-Access-Token': accessToken
-      }
-    })
-
-    const callLimit = response.headers.get('x-shopify-shop-api-call-limit')
-    debug('call-limit', callLimit)
-
-    const retryAfter = response.headers.get('retry-after')
-
-    const link = response.headers.get('link')
-    var result = await response.json()
-    result.link = link
-
-    // try {
-    //   createPayloadLog(shop, path, qs || '', result, {
-    //     state: { domain: null }
-    //   })
-    // } catch (e) {}
-    debug('response result', result)
-
-    return result
-  }
-
-  async post(path: string, data: any = {}) {
-    const { shop, accessToken } = this.config
-
-    debug('data', data)
-
-    const jsondata = JSON.stringify(data)
-
-    const endpoint = `https://${shop}.myshopify.com/admin/api/2020-01${path}`
-
-    const response = await fetch(endpoint, {
-      method: 'post',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Shopify-Access-Token': accessToken
-      },
-      body: jsondata
-    })
-
-    const result = await response.json()
-    // try {
-    //   createPayloadLog(shop, path, jsondata, result, {
-    //     state: { domain: null }
-    //   })
-    // } catch (e) {}
-    debug('response result', result)
-
-    return result
-  }
-
-  async put(path: string, data: any = {}) {
-    const { shop, accessToken } = this.config
-
-    debug('data', data)
-
-    const jsondata = JSON.stringify(data)
-
-    const endpoint = `https://${shop}.myshopify.com/admin/api/2020-01${path}`
-
-    const response = await fetch(endpoint, {
-      method: 'put',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-Shopify-Access-Token': accessToken
-      },
-      body: jsondata
-    })
-
-    const result = await response.json()
-    // try {
-    //   createPayloadLog(shop, path, jsondata, result, {
-    //     state: { domain: null }
-    //   })
-    // } catch (e) {}
-    debug('response result', result)
-
-    return result
-  }
-}

package/server/controllers/store-api/decorators.ts

@@ -1,44 +0,0 @@
-import Debug from 'debug'
-const debug = Debug('things-factory:integration-marketplace:store-api-decorator')
-
-import { MarketplaceStore } from '../../entities'
-
-const NOOP = v => v
-
-export const api = (target: Object, property: string, descriptor: TypedPropertyDescriptor<any>): any => {
-  const method = descriptor.value
-
-  descriptor.value = async function (store: MarketplaceStore, request) {
-    const StoreAPI = this
-
-    var { platform } = store
-
-    var { action: platformAction, apis } = StoreAPI.getPlatform(platform)
-
-    var m = apis[method.name]
-    if (!m) {
-      throw Error(`Marketplace Platform '${platform}' doesn't have API ${method.name}`)
-    }
-
-    var {
-      path,
-      method: httpMethod = 'post',
-      denormalize = NOOP,
-      normalize = NOOP,
-      action = platformAction
-    } = m.apply(this, [request])
-
-    var denormalized = await denormalize(request || {}, { store })
-    debug('request', denormalized)
-
-    var response = await action.apply(this, [
-      { store, method: httpMethod, path, request: denormalized, platformAction }
-    ])
-
-    debug('response', response)
-
-    return await normalize(response, { store })
-  }
-
-  return descriptor
-}