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

package/lib/product-discounts-actions.js

@@ -0,0 +1,27 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.baseActionsList = undefined
+exports.actionsMapBase = actionsMapBase
+
+var _commonActions = require('./utils/common-actions')
+
+var baseActionsList = (exports.baseActionsList = [
+  { action: 'changeIsActive', key: 'isActive' },
+  { action: 'changeName', key: 'name' },
+  { action: 'changePredicate', key: 'predicate' },
+  { action: 'changeSortOrder', key: 'sortOrder' },
+  { action: 'changeValue', key: 'value' },
+  { action: 'setDescription', key: 'description' },
+])
+
+function actionsMapBase(diff, oldObj, newObj) {
+  return (0, _commonActions.buildBaseAttributesActions)({
+    actions: baseActionsList,
+    diff: diff,
+    oldObj: oldObj,
+    newObj: newObj,
+  })
+}

package/lib/product-discounts.js

@@ -0,0 +1,71 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.actionGroups = undefined
+
+var _lodash = require('lodash.flatten')
+
+var _lodash2 = _interopRequireDefault(_lodash)
+
+var _createBuildActions = require('./utils/create-build-actions')
+
+var _createBuildActions2 = _interopRequireDefault(_createBuildActions)
+
+var _createMapActionGroup = require('./utils/create-map-action-group')
+
+var _createMapActionGroup2 = _interopRequireDefault(_createMapActionGroup)
+
+var _productDiscountsActions = require('./product-discounts-actions')
+
+var _diffpatcher = require('./utils/diffpatcher')
+
+var diffpatcher = _interopRequireWildcard(_diffpatcher)
+
+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 }
+}
+
+var actionGroups = (exports.actionGroups = ['base'])
+
+function createProductDiscountsMapActions(mapActionGroup) {
+  return function doMapActions(diff, newObj, oldObj) {
+    var allActions = []
+
+    allActions.push(
+      mapActionGroup('base', function() {
+        return (0,
+        _productDiscountsActions.actionsMapBase)(diff, oldObj, newObj)
+      })
+    )
+
+    return (0, _lodash2.default)(allActions)
+  }
+}
+
+exports.default = function(config) {
+  var mapActionGroup = (0, _createMapActionGroup2.default)(config)
+  var doMapActions = createProductDiscountsMapActions(mapActionGroup)
+  var buildActions = (0, _createBuildActions2.default)(
+    diffpatcher.diff,
+    doMapActions
+  )
+  return { buildActions: buildActions }
+}

package/lib/products.js

@@ -0,0 +1,208 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.actionGroups = undefined
+
+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
+  }
+
+var _lodash = require('lodash.flatten')
+
+var _lodash2 = _interopRequireDefault(_lodash)
+
+var _createBuildActions = require('./utils/create-build-actions')
+
+var _createBuildActions2 = _interopRequireDefault(_createBuildActions)
+
+var _createMapActionGroup = require('./utils/create-map-action-group')
+
+var _createMapActionGroup2 = _interopRequireDefault(_createMapActionGroup)
+
+var _productActions = require('./product-actions')
+
+var productActions = _interopRequireWildcard(_productActions)
+
+var _diffpatcher = require('./utils/diffpatcher')
+
+var diffpatcher = _interopRequireWildcard(_diffpatcher)
+
+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 _toConsumableArray(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i]
+    }
+    return arr2
+  } else {
+    return Array.from(arr)
+  }
+}
+
+var actionGroups = [
+  'base',
+  'meta',
+  'references',
+  'prices',
+  'attributes',
+  'images',
+  'variants',
+  'categories',
+  'categoryOrderHints',
+]
+
+function createProductMapActions(mapActionGroup) {
+  return function doMapActions(diff, newObj, oldObj, options) {
+    var allActions = []
+    var sameForAllAttributeNames = options.sameForAllAttributeNames
+
+    var variantHashMap = (0, _findMatchingPairs2.default)(
+      diff.variants,
+      oldObj.variants,
+      newObj.variants
+    )
+
+    allActions.push(
+      mapActionGroup('base', function() {
+        return productActions.actionsMapBase(diff, oldObj, newObj)
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('meta', function() {
+        return productActions.actionsMapMeta(diff, oldObj, newObj)
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('references', function() {
+        return productActions.actionsMapReferences(diff, oldObj, newObj)
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('variants', function() {
+        return productActions.actionsMapVariants(diff, oldObj, newObj)
+      })
+    )
+
+    allActions.push(productActions.actionsMapMasterVariant(oldObj, newObj))
+
+    allActions.push(
+      mapActionGroup('attributes', function() {
+        return productActions.actionsMapAttributes(
+          diff,
+          oldObj,
+          newObj,
+          sameForAllAttributeNames || [],
+          variantHashMap
+        )
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('images', function() {
+        return productActions.actionsMapImages(
+          diff,
+          oldObj,
+          newObj,
+          variantHashMap
+        )
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('prices', function() {
+        return productActions.actionsMapPrices(
+          diff,
+          oldObj,
+          newObj,
+          variantHashMap
+        )
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('categories', function() {
+        return productActions.actionsMapCategories(diff)
+      })
+    )
+
+    allActions.push(
+      mapActionGroup('categories', function() {
+        return productActions.actionsMapCategoryOrderHints(diff, oldObj)
+      })
+    )
+
+    return (0, _lodash2.default)(allActions)
+  }
+}
+
+function moveMasterVariantsIntoVariants(before, now) {
+  var move = function move(obj) {
+    return _extends({}, obj, {
+      masterVariant: undefined,
+      variants: [obj.masterVariant].concat(
+        _toConsumableArray(obj.variants || [])
+      ),
+    })
+  }
+  var hasMasterVariant = function hasMasterVariant(obj) {
+    return obj && obj.masterVariant
+  }
+
+  return [
+    hasMasterVariant(before) ? move(before) : before,
+    hasMasterVariant(now) ? move(now) : now,
+  ]
+}
+
+exports.default = function(config) {
+  var mapActionGroup = (0, _createMapActionGroup2.default)(config)
+  var doMapActions = createProductMapActions(mapActionGroup)
+
+  var buildActions = (0, _createBuildActions2.default)(
+    diffpatcher.diff,
+    doMapActions,
+    moveMasterVariantsIntoVariants
+  )
+
+  return { buildActions: buildActions }
+}
+
+exports.actionGroups = actionGroups

package/lib/utils/clone.js

@@ -0,0 +1,9 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.default = clone
+function clone(obj) {
+  return JSON.parse(JSON.stringify(obj))
+}

package/lib/utils/common-actions.js

@@ -0,0 +1,157 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+exports.buildBaseAttributesActions = buildBaseAttributesActions
+exports.buildReferenceActions = buildReferenceActions
+
+var _lodash = require('lodash.isnil')
+
+var _lodash2 = _interopRequireDefault(_lodash)
+
+var _clone = require('./clone')
+
+var _clone2 = _interopRequireDefault(_clone)
+
+var _diffpatcher = require('./diffpatcher')
+
+var diffpatcher = _interopRequireWildcard(_diffpatcher)
+
+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
+}
+
+/**
+ * Builds actions for simple object properties, given a list of actions
+ * E.g. [{ action: `changeName`, key: 'name' }]
+ *
+ * @param  {Array} options.actions - a list of actions to be built
+ * based on the given property
+ * @param  {Object} options.diff - the diff object
+ * @param  {Object} options.oldObj - the object that needs to be updated
+ * @param  {Object} options.newObj - the new representation of the object
+ */
+function buildBaseAttributesActions(_ref) {
+  var actions = _ref.actions,
+    diff = _ref.diff,
+    oldObj = _ref.oldObj,
+    newObj = _ref.newObj
+
+  return actions
+    .map(function(item) {
+      var key = item.key // e.g.: name, description, ...
+      var actionKey = item.actionKey || item.key
+      var delta = diff[key]
+      var before = oldObj[key]
+      var now = newObj[key]
+      var isNotDefinedBefore = (0, _lodash2.default)(oldObj[key])
+      var isNotDefinedNow = (0, _lodash2.default)(newObj[key])
+      if (!delta) return undefined
+
+      if (isNotDefinedNow && isNotDefinedBefore) return undefined
+
+      if (!isNotDefinedNow && isNotDefinedBefore)
+        // no value previously set
+        return _defineProperty({ action: item.action }, actionKey, now)
+
+      /* no new value */
+      if (isNotDefinedNow && !{}.hasOwnProperty.call(newObj, key))
+        return undefined
+
+      if (isNotDefinedNow && {}.hasOwnProperty.call(newObj, key))
+        // value unset
+        return {
+          action: item.action,
+
+          // We need to clone `before` as `patch` will mutate it
+        }
+      var patched = diffpatcher.patch((0, _clone2.default)(before), delta)
+      return _defineProperty({ action: item.action }, actionKey, patched)
+    })
+    .filter(function(action) {
+      return action
+    })
+}
+
+/**
+ * Builds actions for simple reference objects, given a list of actions
+ * E.g. [{ action: `setTaxCategory`, key: 'taxCategory' }]
+ *
+ * @param  {Array} options.actions - a list of actions to be built
+ * based on the given property
+ * @param  {Object} options.diff - the diff object
+ * @param  {Object} options.oldObj - the object that needs to be updated
+ * @param  {Object} options.newObj - the new representation of the object
+ */
+function buildReferenceActions(_ref4) {
+  var actions = _ref4.actions,
+    diff = _ref4.diff,
+    newObj = _ref4.newObj
+
+  return actions
+    .map(function(item) {
+      var action = item.action
+      var key = item.key
+
+      if (
+        diff[key] &&
+        // The `key` value was added or removed
+        (Array.isArray(diff[key]) ||
+          // The `key` value id changed
+          diff[key].id)
+      ) {
+        var newValue = Array.isArray(diff[key])
+          ? diffpatcher.getDeltaValue(diff[key])
+          : newObj[key]
+
+        if (!newValue) return { action: action }
+
+        return _defineProperty(
+          {
+            action: action,
+          },
+          key,
+          {
+            typeId: newValue.typeId,
+            id: newValue.id,
+          }
+        )
+      }
+
+      return undefined
+    })
+    .filter(function(action) {
+      return action
+    })
+}

package/lib/utils/create-build-actions.js

@@ -0,0 +1,74 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+
+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'
+      )
+    }
+  }
+})()
+
+exports.default = createBuildActions
+function applyOnBeforeDiff(before, now, fn) {
+  return fn && typeof fn === 'function' ? fn(before, now) : [before, now]
+}
+
+function createBuildActions(differ, doMapActions, onBeforeDiff) {
+  return function buildActions(now, before) {
+    var options =
+      arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}
+
+    if (!now || !before)
+      throw new Error(
+        'Missing either `newObj` or `oldObj` ' +
+          'in order to build update actions'
+      )
+
+    var _applyOnBeforeDiff = applyOnBeforeDiff(before, now, onBeforeDiff),
+      _applyOnBeforeDiff2 = _slicedToArray(_applyOnBeforeDiff, 2),
+      processedBefore = _applyOnBeforeDiff2[0],
+      processedNow = _applyOnBeforeDiff2[1]
+
+    var diffed = differ(processedBefore, processedNow)
+
+    if (!diffed) return []
+
+    return doMapActions(diffed, processedNow, processedBefore, options)
+  }
+}

package/lib/utils/create-build-array-actions.js

@@ -0,0 +1,146 @@
+'use strict'
+
+Object.defineProperty(exports, '__esModule', {
+  value: true,
+})
+
+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
+      }
+
+exports.default = createBuildArrayActions
+var REGEX_NUMBER = new RegExp(/^\d+$/)
+var REGEX_UNDERSCORE_NUMBER = new RegExp(/^_\d+$/)
+
+var ADD_ACTIONS = (exports.ADD_ACTIONS = 'create')
+var REMOVE_ACTIONS = (exports.REMOVE_ACTIONS = 'remove')
+var CHANGE_ACTIONS = (exports.CHANGE_ACTIONS = 'change')
+
+/**
+ * Generate + configure a function to build actions for nested objects
+ * @param  {string} key    key of the attribute containing the array of
+ *   nested objects
+ * @param  {object} config configuration object that can contain the keys
+ *   [ADD_ACTIONS, REMOVE_ACTIONS, CHANGE_ACTIONS], each of
+ *   which is a function. The function should accept the old + new arrays and
+ *   return an action object.
+ * @return {Array}        The generated array of actions
+ */
+function createBuildArrayActions(key, config) {
+  return function buildArrayActions(diff, oldObj, newObj) {
+    var addActions = []
+    var removeActions = []
+    var changeActions = []
+
+    if (diff[key]) {
+      var arrayDelta = diff[key]
+
+      Object.keys(arrayDelta).forEach(function(index) {
+        if (config[ADD_ACTIONS] && isCreateAction(arrayDelta, index)) {
+          var actionGenerator = config[ADD_ACTIONS]
+          // When adding a new element you don't need the oldObj
+          var action = actionGenerator(newObj[key][index], parseInt(index, 10))
+
+          if (action) addActions.push(action)
+        } else if (
+          config[CHANGE_ACTIONS] &&
+          isChangeAction(arrayDelta, index)
+        ) {
+          var _actionGenerator = config[CHANGE_ACTIONS]
+          // When changing an existing element you need both old + new
+          var _action = _actionGenerator(
+            oldObj[key][index],
+            newObj[key][index],
+            parseInt(index, 10)
+          )
+
+          if (_action) changeActions.push(_action)
+        } else if (
+          config[REMOVE_ACTIONS] &&
+          isRemoveAction(arrayDelta, index)
+        ) {
+          var realIndex = index.replace('_', '')
+          var _actionGenerator2 = config[REMOVE_ACTIONS]
+          // When removing an existing element you don't need the newObj
+          var _action2 = _actionGenerator2(
+            oldObj[key][realIndex],
+            parseInt(realIndex, 10)
+          )
+
+          if (_action2) removeActions.push(_action2)
+        }
+      })
+    }
+
+    return changeActions.concat(removeActions, addActions)
+  }
+}
+
+/**
+ * Tests a delta to see if it represents a create action.
+ * eg. delta:
+ * {
+ *   0: [ { foo: 'bar' } ]
+ * }
+ *
+ * @param  {object}  obj The delta generated by the diffpatcher
+ * @param  {string}  key key of generated delta to examine
+ * @return {Boolean}     Returns true if delta represents a create action,
+ *   false otherwise
+ */
+function isCreateAction(obj, key) {
+  return (
+    REGEX_NUMBER.test(key) && Array.isArray(obj[key]) && obj[key].length === 1
+  )
+}
+
+/**
+ * Tests a delta to see if it represents a change action.
+ * eg. delta:
+ *
+ * {
+ *   0: {
+ *     foo: ['bar', 'baz']
+ *   }
+ * }
+ * @param  {object}  obj The delta generated by the diffpatcher
+ * @param  {string}  key key of generated delta to examine
+ * @return {Boolean}     Returns true if delta represents a change action,
+ *   false otherwise
+ */
+function isChangeAction(obj, key) {
+  return REGEX_NUMBER.test(key) && _typeof(obj[key]) === 'object'
+}
+
+/**
+ * Tests a delta to see if it represents a remove action.
+ * eg. delta:
+ *
+ * {
+ *   _0: [ 'foo', 0, 0 ]
+ * }
+ * @param  {object}  obj The delta generated by the diffpatcher
+ * @param  {string}  key key of generated delta to examine
+ * @return {Boolean}     Returns true if delta represents a remove action,
+ *   false otherwise
+ */
+function isRemoveAction(obj, key) {
+  return (
+    REGEX_UNDERSCORE_NUMBER.test(key) &&
+    Array.isArray(obj[key]) &&
+    obj[key].length === 3 &&
+    _typeof(obj[key][0]) === 'object' &&
+    obj[key][1] === 0 &&
+    obj[key][2] === 0
+  )
+}