@commercetools/sync-actions 6.1.1 → 7.0.0-rc.2

package/lib/product-actions.js

@@ -0,0 +1,779 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.referenceActionsList = exports.metaActionsList = exports.baseActionsList = undefined
+
+var _typeof =
+  typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol'
+    ? function(obj) {
+        return typeof obj
+      }
+    : function(obj) {
+        return obj &&
+          typeof Symbol === 'function' &&
+          obj.constructor === Symbol &&
+          obj !== Symbol.prototype
+          ? 'symbol'
+          : typeof obj
+      }
+
+var _slicedToArray = (function() {
+  function sliceIterator(arr, i) {
+    var _arr = []
+    var _n = true
+    var _d = false
+    var _e = undefined
+    try {
+      for (
+        var _i = arr[Symbol.iterator](), _s;
+        !(_n = (_s = _i.next()).done);
+        _n = true
+      ) {
+        _arr.push(_s.value)
+        if (i && _arr.length === i) break
+      }
+    } catch (err) {
+      _d = true
+      _e = err
+    } finally {
+      try {
+        if (!_n && _i['return']) _i['return']()
+      } finally {
+        if (_d) throw _e
+      }
+    }
+    return _arr
+  }
+  return function(arr, i) {
+    if (Array.isArray(arr)) {
+      return arr
+    } else if (Symbol.iterator in Object(arr)) {
+      return sliceIterator(arr, i)
+    } else {
+      throw new TypeError(
+        'Invalid attempt to destructure non-iterable instance'
+      )
+    }
+  }
+})()
+
+var _extends =
+  Object.assign ||
+  function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i]
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key]
+        }
+      }
+    }
+    return target
+  } /* eslint-disable max-len */
+
+exports.actionsMapBase = actionsMapBase
+exports.actionsMapMeta = actionsMapMeta
+exports.actionsMapVariants = actionsMapVariants
+exports.actionsMapReferences = actionsMapReferences
+exports.actionsMapCategories = actionsMapCategories
+exports.actionsMapCategoryOrderHints = actionsMapCategoryOrderHints
+exports.actionsMapAttributes = actionsMapAttributes
+exports.actionsMapImages = actionsMapImages
+exports.actionsMapPrices = actionsMapPrices
+exports.actionsMapMasterVariant = actionsMapMasterVariant
+
+var _lodash = require('lodash.foreach')
+
+var _lodash2 = _interopRequireDefault(_lodash)
+
+var _lodash3 = require('lodash.uniqwith')
+
+var _lodash4 = _interopRequireDefault(_lodash3)
+
+var _diffpatcher = require('./utils/diffpatcher')
+
+var diffpatcher = _interopRequireWildcard(_diffpatcher)
+
+var _commonActions = require('./utils/common-actions')
+
+var _createBuildArrayActions = require('./utils/create-build-array-actions')
+
+var _createBuildArrayActions2 = _interopRequireDefault(_createBuildArrayActions)
+
+var _findMatchingPairs = require('./utils/find-matching-pairs')
+
+var _findMatchingPairs2 = _interopRequireDefault(_findMatchingPairs)
+
+function _interopRequireWildcard(obj) {
+  if (obj && obj.__esModule) {
+    return obj
+  } else {
+    var newObj = {}
+    if (obj != null) {
+      for (var key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key))
+          newObj[key] = obj[key]
+      }
+    }
+    newObj.default = obj
+    return newObj
+  }
+}
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj }
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true,
+    })
+  } else {
+    obj[key] = value
+  }
+  return obj
+}
+
+var REGEX_NUMBER = new RegExp(/^\d+$/)
+var REGEX_UNDERSCORE_NUMBER = new RegExp(/^_\d+$/)
+
+var baseActionsList = (exports.baseActionsList = [
+  { action: 'changeName', key: 'name' },
+  { action: 'changeSlug', key: 'slug' },
+  { action: 'setDescription', key: 'description' },
+  { action: 'setSearchKeywords', key: 'searchKeywords' },
+  { action: 'setKey', key: 'key' },
+])
+
+var metaActionsList = (exports.metaActionsList = [
+  { action: 'setMetaTitle', key: 'metaTitle' },
+  { action: 'setMetaDescription', key: 'metaDescription' },
+  { action: 'setMetaKeywords', key: 'metaKeywords' },
+])
+
+var referenceActionsList = (exports.referenceActionsList = [
+  { action: 'setTaxCategory', key: 'taxCategory' },
+  { action: 'transitionState', key: 'state' },
+])
+
+/**
+ * SYNC FUNCTIONS
+ */
+
+function actionsMapBase(diff, oldObj, newObj) {
+  return (0, _commonActions.buildBaseAttributesActions)({
+    actions: baseActionsList,
+    diff: diff,
+    oldObj: oldObj,
+    newObj: newObj,
+  })
+}
+
+function actionsMapMeta(diff, oldObj, newObj) {
+  return (0, _commonActions.buildBaseAttributesActions)({
+    actions: metaActionsList,
+    diff: diff,
+    oldObj: oldObj,
+    newObj: newObj,
+  })
+}
+
+function actionsMapVariants(diff, oldObj, newObj) {
+  var _createBuildArrayActi
+
+  var handler = (0, _createBuildArrayActions2.default)(
+    'variants',
+    ((_createBuildArrayActi = {}),
+    _defineProperty(
+      _createBuildArrayActi,
+      _createBuildArrayActions.ADD_ACTIONS,
+      function(newObject) {
+        return _extends({}, newObject, {
+          action: 'addVariant',
+        })
+      }
+    ),
+    _defineProperty(
+      _createBuildArrayActi,
+      _createBuildArrayActions.REMOVE_ACTIONS,
+      function(_ref) {
+        var id = _ref.id
+        return {
+          action: 'removeVariant',
+          id: id,
+        }
+      }
+    ),
+    _createBuildArrayActi)
+  )
+
+  return handler(diff, oldObj, newObj)
+}
+
+function actionsMapReferences(diff, oldObj, newObj) {
+  return (0, _commonActions.buildReferenceActions)({
+    actions: referenceActionsList,
+    diff: diff,
+    oldObj: oldObj,
+    newObj: newObj,
+  })
+}
+
+function actionsMapCategories(diff) {
+  var actions = []
+  if (!diff.categories) return actions
+
+  var addToCategoryActions = []
+  var removeFromCategoryActions = []
+  ;(0, _lodash2.default)(diff.categories, function(category) {
+    if (Array.isArray(category)) {
+      var action = { category: category[0] }
+
+      if (category.length === 3) {
+        // Ignore pure array moves!
+        if (category[2] !== 3) {
+          action.action = 'removeFromCategory'
+          removeFromCategoryActions.push(action)
+        }
+      } else if (category.length === 1) {
+        action.action = 'addToCategory'
+        addToCategoryActions.push(action)
+      }
+    }
+  })
+
+  // Make sure `removeFromCategory` actions come first
+  return removeFromCategoryActions.concat(addToCategoryActions)
+}
+
+function actionsMapCategoryOrderHints(diff) {
+  if (!diff.categoryOrderHints) return []
+
+  return Object.keys(diff.categoryOrderHints).map(function(categoryId) {
+    var hintChange = diff.categoryOrderHints[categoryId]
+
+    var action = {
+      action: 'setCategoryOrderHint',
+      categoryId: categoryId,
+    }
+
+    if (hintChange.length === 1)
+      // item was added
+      action.orderHint = hintChange[0]
+    else if (hintChange.length === 2 && hintChange[1] !== 0)
+      // item was changed
+      action.orderHint = hintChange[1]
+
+    // else item was removed -> do not set 'orderHint' property
+
+    return action
+  })
+}
+
+function actionsMapAttributes(diff, oldObj, newObj) {
+  var sameForAllAttributeNames =
+    arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : []
+  var variantHashMap = arguments[4]
+
+  var actions = []
+  var variants = diff.variants
+
+  if (variants)
+    (0, _lodash2.default)(variants, function(variant, key) {
+      var _extractMatchingNewAn = _extractMatchingNewAndOld(
+          variantHashMap,
+          key,
+          oldObj.variants,
+          newObj.variants
+        ),
+        oldVariant = _extractMatchingNewAn.oldObj,
+        newVariant = _extractMatchingNewAn.newObj
+
+      if (REGEX_NUMBER.test(key) && !Array.isArray(variant)) {
+        var skuAction = _buildSkuActions(variant, oldVariant)
+        var keyAction = _buildKeyActions(variant, oldVariant)
+        if (skuAction) actions.push(skuAction)
+        if (keyAction) actions.push(keyAction)
+
+        var attributes = variant.attributes
+
+        var attrActions = _buildVariantAttributesActions(
+          attributes,
+          oldVariant,
+          newVariant,
+          sameForAllAttributeNames
+        )
+        actions = actions.concat(attrActions)
+      }
+    })
+
+  // Ensure that an action is unique.
+  // This is especially necessary for SFA attributes.
+  return (0, _lodash4.default)(actions, function(a, b) {
+    return (
+      a.action === b.action && a.name === b.name && a.variantId === b.variantId
+    )
+  })
+}
+
+function actionsMapImages(diff, oldObj, newObj, variantHashMap) {
+  var actions = []
+  var variants = diff.variants
+
+  if (variants)
+    (0, _lodash2.default)(variants, function(variant, key) {
+      var _extractMatchingNewAn2 = _extractMatchingNewAndOld(
+          variantHashMap,
+          key,
+          oldObj.variants,
+          newObj.variants
+        ),
+        oldVariant = _extractMatchingNewAn2.oldObj,
+        newVariant = _extractMatchingNewAn2.newObj
+
+      if (REGEX_UNDERSCORE_NUMBER.test(key) || REGEX_NUMBER.test(key)) {
+        var vActions = _buildVariantImagesAction(
+          variant.images,
+          oldVariant,
+          newVariant
+        )
+        actions = actions.concat(vActions)
+      }
+    })
+
+  return actions
+}
+
+function actionsMapPrices(diff, oldObj, newObj, variantHashMap) {
+  var addPriceActions = []
+  var changePriceActions = []
+  var removePriceActions = []
+
+  var variants = diff.variants
+
+  if (variants)
+    (0, _lodash2.default)(variants, function(variant, key) {
+      var _extractMatchingNewAn3 = _extractMatchingNewAndOld(
+          variantHashMap,
+          key,
+          oldObj.variants,
+          newObj.variants
+        ),
+        oldVariant = _extractMatchingNewAn3.oldObj,
+        newVariant = _extractMatchingNewAn3.newObj
+
+      if (REGEX_UNDERSCORE_NUMBER.test(key) || REGEX_NUMBER.test(key)) {
+        var _buildVariantPricesAc = _buildVariantPricesAction(
+            variant.prices,
+            oldVariant,
+            newVariant
+          ),
+          _buildVariantPricesAc2 = _slicedToArray(_buildVariantPricesAc, 3),
+          a = _buildVariantPricesAc2[0],
+          c = _buildVariantPricesAc2[1],
+          r = _buildVariantPricesAc2[2]
+
+        addPriceActions = addPriceActions.concat(a)
+        changePriceActions = changePriceActions.concat(c)
+        removePriceActions = removePriceActions.concat(r)
+      }
+    })
+
+  return changePriceActions.concat(removePriceActions).concat(addPriceActions)
+}
+
+function actionsMapMasterVariant(oldObj, newObj) {
+  var createChangeMasterVariantAction = function createChangeMasterVariantAction(
+    variantId
+  ) {
+    return {
+      action: 'changeMasterVariant',
+      variantId: variantId,
+    }
+  }
+  var extractMasterVariantId = function extractMasterVariantId(fromObj) {
+    var variants = Array.isArray(fromObj.variants) ? fromObj.variants : []
+
+    return variants[0] ? variants[0].id : undefined
+  }
+
+  var newMasterVariantId = extractMasterVariantId(newObj)
+  var oldMasterVariantId = extractMasterVariantId(oldObj)
+
+  // Old and new master master variant differ and a new master variant id exists
+  if (newMasterVariantId && oldMasterVariantId !== newMasterVariantId)
+    return [createChangeMasterVariantAction(newMasterVariantId)]
+
+  return []
+}
+
+/**
+ * HELPER FUNCTIONS
+ */
+
+function _buildSkuActions(variantDiff, oldVariant) {
+  if ({}.hasOwnProperty.call(variantDiff, 'sku')) {
+    var newValue = diffpatcher.getDeltaValue(variantDiff.sku)
+    if (!newValue && !oldVariant.sku) return null
+
+    return {
+      action: 'setSku',
+      variantId: oldVariant.id,
+      sku: newValue || null,
+    }
+  }
+  return null
+}
+
+function _buildKeyActions(variantDiff, oldVariant) {
+  if ({}.hasOwnProperty.call(variantDiff, 'key')) {
+    var newValue = diffpatcher.getDeltaValue(variantDiff.key)
+    if (!newValue && !oldVariant.key) return null
+
+    return {
+      action: 'setProductVariantKey',
+      variantId: oldVariant.id,
+      key: newValue || null,
+    }
+  }
+  return null
+}
+
+function _buildVariantAttributesActions(
+  attributes,
+  oldVariant,
+  newVariant,
+  sameForAllAttributeNames
+) {
+  var actions = []
+
+  if (!attributes) return actions
+  ;(0, _lodash2.default)(attributes, function(value, key) {
+    if (REGEX_NUMBER.test(key)) {
+      if (Array.isArray(value)) {
+        var id = oldVariant.id
+
+        var deltaValue = diffpatcher.getDeltaValue(value)
+        var setAction = _buildNewSetAttributeAction(
+          id,
+          deltaValue,
+          sameForAllAttributeNames
+        )
+
+        if (setAction) actions.push(setAction)
+      } else if (newVariant.attributes) {
+        var _setAction = _buildSetAttributeAction(
+          value.value,
+          oldVariant,
+          newVariant.attributes[key],
+          sameForAllAttributeNames
+        )
+        if (_setAction) actions.push(_setAction)
+      }
+    } else if (REGEX_UNDERSCORE_NUMBER.test(key))
+      if (Array.isArray(value)) {
+        // Ignore pure array moves!
+        if (value.length === 3 && value[2] === 3) return
+
+        var _id = oldVariant.id
+
+        var _deltaValue = diffpatcher.getDeltaValue(value)
+        if (!_deltaValue)
+          if (value[0] && value[0].name)
+            // unset attribute if
+            _deltaValue = { name: value[0].name }
+          else _deltaValue = undefined
+
+        var _setAction2 = _buildNewSetAttributeAction(
+          _id,
+          _deltaValue,
+          sameForAllAttributeNames
+        )
+
+        if (_setAction2) actions.push(_setAction2)
+      } else {
+        var index = key.substring(1)
+        if (newVariant.attributes) {
+          var _setAction3 = _buildSetAttributeAction(
+            value.value,
+            oldVariant,
+            newVariant.attributes[index],
+            sameForAllAttributeNames
+          )
+          if (_setAction3) actions.push(_setAction3)
+        }
+      }
+  })
+
+  return actions
+}
+
+function _buildNewSetAttributeAction(id, el, sameForAllAttributeNames) {
+  var attributeName = el && el.name
+  if (!attributeName) return undefined
+
+  var action = {
+    action: 'setAttribute',
+    variantId: id,
+    name: attributeName,
+    value: el.value,
+  }
+
+  if (sameForAllAttributeNames.indexOf(attributeName) !== -1) {
+    Object.assign(action, { action: 'setAttributeInAllVariants' })
+    delete action.variantId
+  }
+
+  return action
+}
+
+function _buildSetAttributeAction(
+  diffedValue,
+  oldVariant,
+  attribute,
+  sameForAllAttributeNames
+) {
+  if (!attribute) return undefined
+
+  var action = {
+    action: 'setAttribute',
+    variantId: oldVariant.id,
+    name: attribute.name,
+
+    // Used as original object for patching long diff text
+  }
+  var oldAttribute =
+    oldVariant.attributes.find(function(a) {
+      return a.name === attribute.name
+    }) || {}
+
+  if (sameForAllAttributeNames.indexOf(attribute.name) !== -1) {
+    Object.assign(action, { action: 'setAttributeInAllVariants' })
+    delete action.variantId
+  }
+
+  if (Array.isArray(diffedValue))
+    action.value = diffpatcher.getDeltaValue(diffedValue, oldAttribute.value)
+  else if (typeof diffedValue === 'string')
+    // LText: value: {en: "", de: ""}
+    // Enum: value: {key: "foo", label: "Foo"}
+    // LEnum: value: {key: "foo", label: {en: "Foo", de: "Foo"}}
+    // Money: value: {centAmount: 123, currencyCode: ""}
+    // *: value: ""
+
+    // normal
+    action.value = diffpatcher.getDeltaValue(diffedValue, oldAttribute.value)
+  else if (diffedValue.centAmount || diffedValue.currencyCode)
+    // Money
+    action.value = {
+      centAmount: diffedValue.centAmount
+        ? diffpatcher.getDeltaValue(diffedValue.centAmount)
+        : attribute.value.centAmount,
+      currencyCode: diffedValue.currencyCode
+        ? diffpatcher.getDeltaValue(diffedValue.currencyCode)
+        : attribute.value.currencyCode,
+    }
+  else if (diffedValue.key)
+    // Enum / LEnum (use only the key)
+    action.value = diffpatcher.getDeltaValue(diffedValue.key)
+  else if (
+    (typeof diffedValue === 'undefined'
+      ? 'undefined'
+      : _typeof(diffedValue)) === 'object'
+  )
+    if (
+      {}.hasOwnProperty.call(diffedValue, '_t') &&
+      diffedValue['_t'] === 'a'
+    ) {
+      // set-typed attribute
+      Object.assign(action, { value: attribute.value })
+    } else {
+      // LText
+
+      var updatedValue = Object.keys(diffedValue).reduce(function(acc, lang) {
+        var patchedValue = diffpatcher.getDeltaValue(
+          diffedValue[lang],
+          acc[lang]
+        )
+        return Object.assign(acc, _defineProperty({}, lang, patchedValue))
+      }, Object.assign({}, oldAttribute.value))
+
+      action.value = updatedValue
+    }
+
+  return action
+}
+
+function _buildVariantImagesAction(diffedImages) {
+  var oldVariant =
+    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
+  var newVariant =
+    arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}
+
+  var actions = []
+  // generate a hashMap to be able to reference the right image from both ends
+  var matchingImagePairs = (0, _findMatchingPairs2.default)(
+    diffedImages,
+    oldVariant.images,
+    newVariant.images,
+    'url'
+  )
+  ;(0, _lodash2.default)(diffedImages, function(image, key) {
+    var _extractMatchingNewAn4 = _extractMatchingNewAndOld(
+        matchingImagePairs,
+        key,
+        oldVariant.images,
+        newVariant.images
+      ),
+      oldObj = _extractMatchingNewAn4.oldObj,
+      newObj = _extractMatchingNewAn4.newObj
+
+    if (REGEX_NUMBER.test(key)) {
+      // New image
+      if (Array.isArray(image) && image.length)
+        actions.push({
+          action: 'addExternalImage',
+          variantId: oldVariant.id,
+          image: diffpatcher.getDeltaValue(image),
+        })
+      else if (
+        (typeof image === 'undefined' ? 'undefined' : _typeof(image)) ===
+        'object'
+      )
+        if ({}.hasOwnProperty.call(image, 'url') && image.url.length === 2) {
+          // There is a new image, remove the old one first.
+          actions.push({
+            action: 'removeImage',
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+          })
+          actions.push({
+            action: 'addExternalImage',
+            variantId: oldVariant.id,
+            image: newObj,
+          })
+        } else if (
+          {}.hasOwnProperty.call(image, 'label') &&
+          (image.label.length === 1 || image.label.length === 2)
+        )
+          actions.push({
+            action: 'setImageLabel',
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+            label: diffpatcher.getDeltaValue(image.label),
+          })
+    } else if (REGEX_UNDERSCORE_NUMBER.test(key))
+      if (Array.isArray(image) && image.length === 3) {
+        if (Number(image[2]) === 3)
+          // image position changed
+          actions.push({
+            action: 'moveImagetoPosition',
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+            position: Number(image[1]),
+          })
+        else if (Number(image[2]) === 0)
+          // image removed
+          actions.push({
+            action: 'removeImage',
+            variantId: oldVariant.id,
+            imageUrl: oldObj.url,
+          })
+      }
+  })
+
+  return actions
+}
+
+// safely extract oldObj and newObj
+function _extractMatchingNewAndOld(hashMap, key, before, now) {
+  var oldObjPos = void 0
+  var newObjPos = void 0
+  var oldObj = void 0
+  var newObj = void 0
+
+  if (hashMap[key]) {
+    oldObjPos = hashMap[key][0]
+    newObjPos = hashMap[key][1]
+    if (before && before[oldObjPos]) oldObj = before[oldObjPos]
+
+    if (now && now[newObjPos]) newObj = now[newObjPos]
+  }
+  return { oldObj: oldObj, newObj: newObj }
+}
+
+function _buildVariantPricesAction(diffedPrices) {
+  var oldVariant =
+    arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}
+  var newVariant =
+    arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}
+
+  var addPriceActions = []
+  var changePriceActions = []
+  var removePriceActions = []
+
+  // generate a hashMap to be able to reference the right image from both ends
+  var matchingPricePairs = (0, _findMatchingPairs2.default)(
+    diffedPrices,
+    oldVariant.prices,
+    newVariant.prices
+  )
+  ;(0, _lodash2.default)(diffedPrices, function(price, key) {
+    var _extractMatchingNewAn5 = _extractMatchingNewAndOld(
+        matchingPricePairs,
+        key,
+        oldVariant.prices,
+        newVariant.prices
+      ),
+      oldObj = _extractMatchingNewAn5.oldObj,
+      newObj = _extractMatchingNewAn5.newObj
+
+    if (REGEX_NUMBER.test(key)) {
+      if (Array.isArray(price) && price.length) {
+        // Remove read-only fields
+        var patchedPrice = price.map(function(p) {
+          var shallowClone = Object.assign({}, p)
+          delete shallowClone.discounted
+          return shallowClone
+        })
+
+        addPriceActions.push({
+          action: 'addPrice',
+          variantId: oldVariant.id,
+          price: diffpatcher.getDeltaValue(patchedPrice),
+        })
+      } else if (Object.keys(price).length) {
+        // Remove the discounted field and make sure that the price
+        // still has other values, otherwise simply return
+        var filteredPrice = Object.assign({}, price)
+        delete filteredPrice.discounted
+        if (Object.keys(filteredPrice).length) {
+          // At this point price should have changed, simply pick the new one
+          var newPrice = Object.assign({}, newObj)
+          delete newPrice.discounted
+
+          changePriceActions.push({
+            action: 'changePrice',
+            priceId: oldObj.id,
+            price: newPrice,
+          })
+        }
+      }
+    } else if (REGEX_UNDERSCORE_NUMBER.test(key))
+      if (Number(price[2]) === 0) {
+        // price removed
+        removePriceActions.push({
+          action: 'removePrice',
+          priceId: oldObj.id,
+        })
+      }
+  })
+
+  return [addPriceActions, changePriceActions, removePriceActions]
+}