@things-factory/integration-marketplace 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,19 @@
+/* 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

@@ -0,0 +1,18 @@
+/* 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,14 @@
+/* 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

@@ -0,0 +1,177 @@
+/* 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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,31 @@
+/* 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

@@ -0,0 +1,32 @@
+/* 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

@@ -0,0 +1,26 @@
+/*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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,26 @@
+/*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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,148 @@
+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

@@ -0,0 +1,44 @@
+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
+}