@darkpos/pricing 1.0.6 → 1.0.7

package/lib/modifier/index.js

@@ -0,0 +1,242 @@
+//
+const addFile = require('./addFile');
+const addImage = require('./addImage');
+const calculate = require('./calculate');
+const contains = require('./contains');
+const convertMenuModifiers = require('./convertMenuModifiers');
+const create = require('./create');
+const createAmountOverrideModifier = require('./createAmountOverrideModifier');
+const createCreditModifier = require('./createCreditModifier');
+const createDiscountModifier = require('./createDiscountModifier');
+const createGroupValuesModifier = require('./createGroupValuesModifier');
+const createIndirectModifier = require('./createIndirectModifier');
+const createSubscriptionModifier = require('./createSubscriptionModifier');
+const displayAsCard = require('./displayAsCard');
+const displayAsChips = require('./displayAsChips');
+const displayAsList = require('./displayAsList');
+const duplicate = require('./duplicate');
+const enableAutoPopup = require('./enableAutoPopup');
+const filterByRequiredModifiers = require('./filterByRequiredModifiers');
+const findById = require('./findById');
+const findByPaymentMethod = require('./findByPaymentMethod');
+const findByPaymentType = require('./findByPaymentType');
+const getAvailablePromotions = require('./getAvailablePromotions');
+const getAvailablePromotionsOrSubscriptions = require('./getAvailablePromotionsOrSubscriptions');
+const getAvailableSubscriptions = require('./getAvailableSubscriptions');
+const getByAttribute = require('./getByAttribute');
+const getCreditModifier = require('./getCreditModifier');
+const getDefaultModifiers = require('./getDefaultModifiers');
+const getDepartmentModifiers = require('./getDepartmentModifiers');
+const getDiscountModifiers = require('./getDiscountModifiers');
+const getDescription = require('./getDescription');
+const getDepartmentMaxItems = require('./getDepartmentMaxItems');
+const getDirectModifiers = require('./getDirectModifiers');
+const getDescriptions = require('./getDescriptions');
+const getEntityModifiers = require('./getEntityModifiers');
+const getExtendedTags = require('./getExtendedTags');
+const getEntityPromotions = require('./getEntityPromotions');
+const getFiles = require('./getFiles');
+const getGroupOfItemsModifiers = require('./getGroupOfItemsModifiers');
+const getGroupRelatedModifiers = require('./getGroupRelatedModifiers');
+const getGroupModifiers = require('./getGroupModifiers');
+const getImages = require('./getImages');
+const getItemModifiers = require('./getItemModifiers');
+const getInheritedModifiers = require('./getInheritedModifiers');
+const getLaundryModifiers = require('./getLaundryModifiers');
+const getMatchTagsModifiers = require('./getMatchTagsModifiers');
+const getModifierIndex = require('./getModifierIndex');
+const getPreferences = require('./getPreferences');
+const getPromotionModifiers = require('./getPromotionModifiers');
+const getPromptMessage = require('./getPromptMessage');
+const getProperty = require('./getProperty');
+const getRelatedModifiers = require('./getRelatedModifiers');
+const getRecommendedModifiers = require('./getRecommendedModifiers');
+const getRequiredModifiers = require('./getRequiredModifiers');
+const getSelectedValues = require('./getSelectedValues');
+const getSubscriptionItem = require('./getSubscriptionItem');
+const getSubscriptionModifiers = require('./getSubscriptionModifiers');
+const getStarchModifier = require('./getStarchModifier');
+const getService = require('./getService');
+const getSplittedModifiers = require('./getSplittedModifiers');
+const getSuggestion = require('./getSuggestion');
+const getUnhiddenModifiers = require('./getUnhiddenModifiers');
+const getUsingCount = require('./getUsingCount');
+const hasAddModifiers = require('./hasAddModifiers');
+const hasAllTag = require('./hasAllTag');
+const hasAttribute = require('./hasAttribute');
+const hasAttributes = require('./hasAttributes');
+const hasCreateSubscription = require('./hasCreateSubscription');
+const hasDisplayPrompt = require('./hasDisplayPrompt');
+const hasMatchTags = require('./hasMatchTags');
+const hasModifier = require('./hasModifier');
+const hasRelatedItems = require('./hasRelatedItems');
+const includePiecesInQuantity = require('./includePiecesInQuantity');
+const includesInGroup = require('./includesInGroup');
+const isTrackUsageSubscription = require('./isTrackUsageSubscription');
+const isDirect = require('./isDirect');
+const hasNoTags = require('./hasNoTags');
+const isRemoveModifier = require('./isRemoveModifier');
+const isGroupOfModifiers = require('./isGroupOfModifiers');
+const isRequiredAndOverride = require('./isRequiredAndOverride');
+const isManual = require('./isManual');
+const isPriceOverride = require('./isPriceOverride');
+const isQuantityOverride = require('./isQuantityOverride');
+const isService = require('./isService');
+const isSingleValue = require('./isSingleValue');
+const isGroupOfItems = require('./isGroupOfItems');
+const isOverride = require('./isOverride');
+const isDepartment = require('./isDepartment');
+const isRequired = require('./isRequired');
+const isMultiplier = require('./isMultiplier');
+const isAvailablePromotion = require('./isAvailablePromotion');
+const isAvailableSubscription = require('./isAvailableSubscription');
+const isPromotion = require('./isPromotion');
+const isSubscription = require('./isSubscription');
+const isDefault = require('./isDefault');
+const isIncluded = require('./isIncluded');
+const isCustomerTagsExtend = require('./isCustomerTagsExtend');
+const isAmountOverride = require('./isAmountOverride');
+const isDiscount = require('./isDiscount');
+const isHidden = require('./isHidden');
+const isGratuity = require('./isGratuity');
+const isPaymentMethods = require('./isPaymentMethods');
+const isPaymentTypes = require('./isPaymentTypes');
+const isPreferences = require('./isPreferences');
+const isGroupOfValues = require('./isGroupOfValues');
+const isCompact = require('./isCompact');
+const isValueSelected = require('./isValueSelected');
+const isEditable = require('./isEditable');
+const isCredit = require('./isCredit');
+const purifyModifiers = require('./purifyModifiers');
+const sort = require('./sort');
+
+const modifierActions = (deps = {}) => {
+  const actions = {};
+
+  const innerDeps = {
+    ...deps,
+    actions,
+  };
+
+  const freezedActions = Object.freeze({
+    addFile: addFile(innerDeps),
+    addImage: addImage(innerDeps),
+    calculate: calculate(innerDeps),
+    contains: contains(innerDeps),
+    convertMenuModifiers: convertMenuModifiers(innerDeps),
+    create: create(innerDeps),
+    createAmountOverrideModifier: createAmountOverrideModifier(innerDeps),
+    createCreditModifier: createCreditModifier(innerDeps),
+    createDiscountModifier: createDiscountModifier(innerDeps),
+    createGroupValuesModifier: createGroupValuesModifier(innerDeps),
+    createIndirectModifier: createIndirectModifier(innerDeps),
+    createSubscriptionModifier: createSubscriptionModifier(innerDeps),
+    displayAsCard: displayAsCard(innerDeps),
+    displayAsChips: displayAsChips(innerDeps),
+    displayAsList: displayAsList(innerDeps),
+    duplicate: duplicate(innerDeps),
+    enableAutoPopup: enableAutoPopup(innerDeps),
+    filterByRequiredModifiers: filterByRequiredModifiers(innerDeps),
+    findById: findById(innerDeps),
+    findByPaymentMethod: findByPaymentMethod(innerDeps),
+    findByPaymentType: findByPaymentType(innerDeps),
+    getAvailablePromotions: getAvailablePromotions(innerDeps),
+    getAvailablePromotionsOrSubscriptions:
+      getAvailablePromotionsOrSubscriptions(innerDeps),
+    getAvailableSubscriptions: getAvailableSubscriptions(innerDeps),
+    getByAttribute: getByAttribute(innerDeps),
+    getCreditModifier: getCreditModifier(innerDeps),
+    getDepartmentMaxItems: getDepartmentMaxItems(innerDeps),
+    getDirectModifiers: getDirectModifiers(innerDeps),
+    getDescriptions: getDescriptions(innerDeps),
+    getDepartmentModifiers: getDepartmentModifiers(innerDeps),
+    getDiscountModifiers: getDiscountModifiers(innerDeps),
+    getDescription: getDescription(innerDeps),
+    getDefaultModifiers: getDefaultModifiers(innerDeps),
+    getEntityModifiers: getEntityModifiers(innerDeps),
+    getExtendedTags: getExtendedTags(innerDeps),
+    getEntityPromotions: getEntityPromotions(innerDeps),
+    getFiles: getFiles(innerDeps),
+    getGroupRelatedModifiers: getGroupRelatedModifiers(innerDeps),
+    getGroupModifiers: getGroupModifiers(innerDeps),
+    getGroupOfItemsModifiers: getGroupOfItemsModifiers(innerDeps),
+    getImages: getImages(innerDeps),
+    getInheritedModifiers: getInheritedModifiers(innerDeps),
+    getItemModifiers: getItemModifiers(innerDeps),
+    getLaundryModifiers: getLaundryModifiers(innerDeps),
+    getMatchTagsModifiers: getMatchTagsModifiers(innerDeps),
+    getModifierIndex: getModifierIndex(innerDeps),
+    getPreferences: getPreferences(innerDeps),
+    getPromotionModifiers: getPromotionModifiers(innerDeps),
+    getPromptMessage: getPromptMessage(innerDeps),
+    getProperty: getProperty(innerDeps),
+    getRelatedModifiers: getRelatedModifiers(innerDeps),
+    getRecommendedModifiers: getRecommendedModifiers(innerDeps),
+    getRequiredModifiers: getRequiredModifiers(innerDeps),
+    getSelectedValues: getSelectedValues(innerDeps),
+    getSubscriptionItem: getSubscriptionItem(innerDeps),
+    getSubscriptionModifiers: getSubscriptionModifiers(innerDeps),
+    getStarchModifier: getStarchModifier(innerDeps),
+    getService: getService(innerDeps),
+    getSplittedModifiers: getSplittedModifiers(innerDeps),
+    getSuggestion: getSuggestion(innerDeps),
+    getUnhiddenModifiers: getUnhiddenModifiers(innerDeps),
+    getUsingCount: getUsingCount(innerDeps),
+    hasAddModifiers: hasAddModifiers(innerDeps),
+    hasAllTag: hasAllTag(innerDeps),
+    hasNoTags: hasNoTags(innerDeps),
+    hasCreateSubscription: hasCreateSubscription(innerDeps),
+    hasDisplayPrompt: hasDisplayPrompt(innerDeps),
+    hasMatchTags: hasMatchTags(innerDeps),
+    hasModifier: hasModifier(innerDeps),
+    hasRelatedItems: hasRelatedItems(innerDeps),
+    hasAttribute: hasAttribute(innerDeps),
+    hasAttributes: hasAttributes(innerDeps),
+    includePiecesInQuantity: includePiecesInQuantity(innerDeps),
+    includesInGroup: includesInGroup(innerDeps),
+    isTrackUsageSubscription: isTrackUsageSubscription(innerDeps),
+    isDirect: isDirect(innerDeps),
+    isEditable: isEditable(innerDeps),
+    isRemoveModifier: isRemoveModifier(innerDeps),
+    isGroupOfModifiers: isGroupOfModifiers(innerDeps),
+    isRequiredAndOverride: isRequiredAndOverride(innerDeps),
+    isManual: isManual(innerDeps),
+    isService: isService(innerDeps),
+    isQuantityOverride: isQuantityOverride(innerDeps),
+    isPriceOverride: isPriceOverride(innerDeps),
+    isSingleValue: isSingleValue(innerDeps),
+    isGroupOfItems: isGroupOfItems(innerDeps),
+    isOverride: isOverride(innerDeps),
+    isDepartment: isDepartment(innerDeps),
+    isRequired: isRequired(innerDeps),
+    isMultiplier: isMultiplier(innerDeps),
+    isAvailablePromotion: isAvailablePromotion(innerDeps),
+    isAvailableSubscription: isAvailableSubscription(innerDeps),
+    isPromotion: isPromotion(innerDeps),
+    isSubscription: isSubscription(innerDeps),
+    isDefault: isDefault(innerDeps),
+    isCustomerTagsExtend: isCustomerTagsExtend(innerDeps),
+    isAmountOverride: isAmountOverride(innerDeps),
+    isDiscount: isDiscount(innerDeps),
+    isHidden: isHidden(innerDeps),
+    isGratuity: isGratuity(innerDeps),
+    isPaymentMethods: isPaymentMethods(innerDeps),
+    isPaymentTypes: isPaymentTypes(innerDeps),
+    isPreferences: isPreferences(innerDeps),
+    isGroupOfValues: isGroupOfValues(innerDeps),
+    isCompact: isCompact(innerDeps),
+    isValueSelected: isValueSelected(innerDeps),
+    isCredit: isCredit(innerDeps),
+    isIncluded: isIncluded(innerDeps),
+    purifyModifiers: purifyModifiers(innerDeps),
+    sort: sort(innerDeps),
+  });
+
+  Object.keys(freezedActions).forEach(actionName => {
+    actions[actionName] = freezedActions[actionName];
+  });
+
+  return freezedActions;
+};
+
+module.exports = modifierActions;

package/lib/modifier/isAmountOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isAmountOverride(modifier) {
+    return (
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'amount'
+    );
+  };

package/lib/modifier/isAvailablePromotion.js

@@ -0,0 +1,23 @@
+module.exports = ({ utils, actions }) => {
+  const { date, math } = utils;
+
+  return function isAvailablePromotion(modifier) {
+    if (!actions.isPromotion(modifier)) return false;
+
+    const { promotion } = modifier.properties || {};
+
+    if (!promotion) return true;
+
+    if (
+      promotion.numberOfUses &&
+      promotion.numberOfUsesLimit &&
+      math.gte(promotion.numberOfUses, promotion.numberOfUsesLimit)
+    )
+      return false;
+
+    if (promotion.dateLimit && !date.isBetween(promotion.dateLimit))
+      return false;
+
+    return true;
+  };
+};

package/lib/modifier/isAvailableSubscription.js

@@ -0,0 +1,28 @@
+module.exports = ({ utils, actions }) => {
+  const { date, math } = utils;
+
+  return function isAvailableSubscription(modifier) {
+    if (!actions.isSubscription(modifier)) return false;
+
+    const { subscription } = modifier.properties || {};
+
+    if (!subscription) return false;
+
+    const properties = {
+      ...subscription.item,
+      dateLimit: subscription.dateLimit,
+    };
+
+    if (
+      properties.numberOfUses &&
+      properties.numberOfUsesLimit &&
+      math.gte(properties.numberOfUses, properties.numberOfUsesLimit)
+    )
+      return false;
+
+    if (properties.dateLimit && !date.isBetween(properties.dateLimit))
+      return false;
+
+    return true;
+  };
+};

package/lib/modifier/isCompact.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isCompact(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      properties.group.compact
+    );
+  };
+};

package/lib/modifier/isCredit.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isCredit(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.CREDIT);
+  };
+};

package/lib/modifier/isCustomerTagsExtend.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isCustomerTagsExtend(modifier) {
+    return (
+      modifier &&
+      modifier.properties &&
+      modifier.properties.department &&
+      (modifier.properties.department.customerTagsExtend || []).length
+    );
+  };

package/lib/modifier/isDefault.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isDefault(modifier) {
+    return modifier && modifier.default;
+  };

package/lib/modifier/isDepartment.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isDepartment(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.DEPARTMENT);
+  };
+};

package/lib/modifier/isDirect.js

@@ -0,0 +1,6 @@
+module.exports = () =>
+  function isDirect(modifier) {
+    if (!modifier) return false;
+
+    return modifier.direct;
+  };

package/lib/modifier/isDiscount.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isDiscount(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.DISCOUNT);
+  };
+};

package/lib/modifier/isEditable.js

@@ -0,0 +1,10 @@
+module.exports = ({ actions }) =>
+  function isEditable(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.isGroupOfValues(modifier) &&
+      properties &&
+      properties.group &&
+      properties.group.editGroupValues
+    );
+  };

package/lib/modifier/isGratuity.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants }) => {
+  const { Modifier } = constants;
+  return function isGratuity(modifier) {
+    return !!(modifier && modifier.type === Modifier.Types.GRATUITY);
+  };
+};

package/lib/modifier/isGroupOfItems.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfItems(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      (properties.group.items || []).length
+    );
+  };
+};

package/lib/modifier/isGroupOfModifiers.js

@@ -0,0 +1,12 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfModifiers(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      (properties.group.modifiers || []).length
+    );
+  };
+};

package/lib/modifier/isGroupOfValues.js

@@ -0,0 +1,13 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isGroupOfValues(modifier) {
+    const { properties = {} } = modifier || {};
+    return !!(
+      actions.hasAttribute(modifier, Modifier.Attributes.GROUP) &&
+      properties &&
+      properties.group &&
+      ((properties.group.values || []).length ||
+        (properties.group.selectedValues || []).length)
+    );
+  };
+};

package/lib/modifier/isHidden.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isHidden(modifier) {
+    return modifier.hidden;
+  };

package/lib/modifier/isIncluded.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isIncluded(modifier) {
+    return modifier.included;
+  };

package/lib/modifier/isManual.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isManual(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.override &&
+      modifier.properties.override.type === 'manual'
+    );
+  };

package/lib/modifier/isMultiplier.js

@@ -0,0 +1,11 @@
+module.exports = () =>
+  function isMultiplier(modifier) {
+    if (!modifier) return false;
+    const _modifier = modifier.modifier || modifier;
+    return !!(
+      _modifier &&
+      _modifier.properties &&
+      _modifier.properties.override &&
+      _modifier.properties.override.multiplier
+    );
+  };

package/lib/modifier/isOverride.js

@@ -0,0 +1,6 @@
+module.exports = ({ actions, constants }) => {
+  const { Modifier } = constants;
+  return function isOverride(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.OVERRIDE);
+  };
+};

package/lib/modifier/isPaymentMethods.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isPaymentMethods(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      (modifier.conditions.paymentMethods || []).length
+    );
+  };

package/lib/modifier/isPaymentTypes.js

@@ -0,0 +1,8 @@
+module.exports = () =>
+  function isPaymentTypes(modifier) {
+    return !!(
+      modifier &&
+      modifier.conditions &&
+      (modifier.conditions.paymentTypes || []).length
+    );
+  };

package/lib/modifier/isPreferences.js

@@ -0,0 +1,8 @@
+module.exports = ({ settings, _ }) => {
+  const getPreferencesSettings = () => _.get(settings, 'types.preferences', []);
+
+  return function isPreferences(modifier) {
+    const preferences = getPreferencesSettings();
+    return modifier.group && preferences.includes(modifier.group.toLowerCase());
+  };
+};

package/lib/modifier/isPriceOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isPriceOverride(modifier) {
+    return !!(
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'price'
+    );
+  };

package/lib/modifier/isPromotion.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants, actions }) => {
+  const { Modifier } = constants;
+  return function isPromotion(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.PROMOTION);
+  };
+};

package/lib/modifier/isQuantityOverride.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isQuantityOverride(modifier) {
+    return (
+      actions.isOverride(modifier) &&
+      modifier.properties.override.field === 'quantity'
+    );
+  };

package/lib/modifier/isRemoveModifier.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRemoveModifier(modifier) {
+    return !!(modifier && (modifier.delModifiers || []).length);
+  };

package/lib/modifier/isRequired.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isRequired(modifier) {
+    return modifier && modifier.required;
+  };

package/lib/modifier/isRequiredAndOverride.js

@@ -0,0 +1,4 @@
+module.exports = ({ actions }) =>
+  function isRequiredAndOverride(modifier) {
+    return actions.isOverride(modifier) && actions.isRequired(modifier);
+  };

package/lib/modifier/isService.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isService(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.override &&
+      modifier.properties.override.type === 'service'
+    );
+  };

package/lib/modifier/isSingleValue.js

@@ -0,0 +1,9 @@
+module.exports = () =>
+  function isSingleValue(modifier) {
+    return !!(
+      modifier &&
+      modifier.properties &&
+      modifier.properties.group &&
+      modifier.properties.group.singleValue
+    );
+  };

package/lib/modifier/isSubscription.js

@@ -0,0 +1,6 @@
+module.exports = ({ constants, actions }) => {
+  const { Modifier } = constants;
+  return function isSubscription(modifier) {
+    return actions.hasAttribute(modifier, Modifier.Attributes.SUBSCRIPTION);
+  };
+};

package/lib/modifier/isTrackUsageSubscription.js

@@ -0,0 +1,5 @@
+module.exports = ({ _ }) =>
+  function isTrackUsageSubscription(modifier) {
+    const subscription = _.get(modifier, 'properties.subscription');
+    return !!(subscription && subscription.enabled && subscription.trackUsage);
+  };

package/lib/modifier/isValueSelected.js

@@ -0,0 +1,7 @@
+module.exports = ({ actions }) =>
+  function isValueSelected({ modifier, value }) {
+    if (!modifier || !value) return false;
+    if (!actions.isGroupOfValues(modifier)) return false;
+    if (!Array.isArray(modifier.properties.group.selectedValues)) return false;
+    return modifier.properties.group.selectedValues.includes(value);
+  };

package/lib/modifier/purifyModifiers.js

@@ -0,0 +1,15 @@
+module.exports = ({ actions }) =>
+  function purifyModifiers(modifiers) {
+    if (!modifiers) return [];
+    const removeIds = modifiers
+      .filter(modifier => actions.isRemoveModifier(modifier))
+      .reduce(
+        (acc, modifier) => [
+          ...acc,
+          modifier.properties.delModifiers.map(each => each._id),
+        ],
+        []
+      );
+
+    return modifiers.filter(each => !removeIds.includes(each.modifierId));
+  };

package/lib/modifier/sort.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-prototype-builtins */
+module.exports = () => {
+  function compareValues(key, order = 'asc') {
+    return function innerSort(a, b) {
+      // property doesn't exist on either object
+      if (
+        !a.properties ||
+        !a.properties.hasOwnProperty(key) ||
+        !b.properties ||
+        !b.properties.hasOwnProperty(key)
+      )
+        return 0;
+
+      const varA =
+        typeof a.properties[key] === 'string'
+          ? a.properties[key].toUpperCase()
+          : a.properties[key];
+      const varB =
+        typeof b.properties[key] === 'string'
+          ? b.properties[key].toUpperCase()
+          : b.properties[key];
+
+      let comparison = 0;
+      if (varA > varB) comparison = 1;
+      else if (varA < varB) comparison = -1;
+      return order === 'desc' ? comparison * -1 : comparison;
+    };
+  }
+
+  return function sort(modifiers) {
+    if (!modifiers || !Array.isArray(modifiers)) return modifiers;
+    const compare = compareValues('sort');
+    return modifiers.sort(compare);
+  };
+};

package/lib/order/create.js

@@ -2,9 +2,9 @@ module.exports = ({ utils, constants = {} }) => {
   const { helpers } = utils;
 
   const defaultOrderStatus = {
-    order: constants.status.Order.OPEN,
-    kitchen: constants.status.Kitchen.OPEN,
-    delivery: constants.status.Delivery.NONE,
+    order: constants.Status.Order.OPEN,
+    kitchen: constants.Status.Kitchen.OPEN,
+    delivery: constants.Status.Delivery.NONE,
     detailed: true,
   };
   const orderEnd = {