@darkpos/pricing 1.0.138 → 1.0.139

package/__TEST__/item.test.js

@@ -2570,5 +2570,112 @@ describe('Item actions', () => {
         'City Tax': 3,
       });
     });
+
+    test('mergeWithParentItem adds price, name, and modifiers to parent', () => {
+      const parentItem = {
+        _id: 'parent-1',
+        itemId: 'parent-1',
+        name: 'Parent',
+        price: 100,
+        total: 100,
+        quantity: 1,
+        modifiers: [
+          {
+            _id: 'mod-parent',
+            modifierId: 'mod-parent',
+          },
+        ],
+      };
+
+      const order = {
+        items: [parentItem],
+        modifiers: [],
+      };
+
+      const relatedItem = {
+        itemId: 'child-1',
+        name: 'Child',
+        price: 25,
+        modifiers: [
+          {
+            _id: 'tax',
+            compute: { amount: 5, type: 'fixed', action: 'add' },
+          },
+        ],
+        properties: {
+          relatedItem: true,
+          parentId: parentItem._id,
+          parentItemId: parentItem.itemId,
+          mergeWithParentItem: true,
+        },
+      };
+
+      const { updatedOrder } = pricingService.order.addItem({
+        order,
+        item: relatedItem,
+      });
+
+      expect(updatedOrder.items.length).toBe(1);
+
+      expect(updatedOrder.items[0]._id).toBe('parent-1');
+
+      expect(updatedOrder.items[0].price).toBe(125);
+      expect(updatedOrder.items[0].name).toBe('Parent - Child');
+      expect(updatedOrder.items[0].modifiers.length).toBe(2);
+      expect(updatedOrder.items[0].modifiers[0]._id).toBe('mod-parent');
+      expect(updatedOrder.items[0].modifiers[1].modifierId).toBe('tax');
+    });
+
+    test('mergeWithParentItem does not duplicate parent modifiers', () => {
+      const parentItem = {
+        _id: 'parent-2',
+        itemId: 'parent-2',
+        name: 'Parent',
+        price: 100,
+        total: 100,
+        quantity: 1,
+        modifiers: [
+          {
+            _id: 'mod-shared-parent',
+            modifierId: 'mod-shared',
+          },
+        ],
+      };
+
+      const order = {
+        items: [parentItem],
+        modifiers: [],
+      };
+
+      const relatedItem = {
+        itemId: 'child-2',
+        name: 'Child',
+        price: 10,
+        modifiers: [
+          {
+            _id: 'mod-shared',
+            compute: { amount: 2, type: 'fixed', action: 'add' },
+          },
+        ],
+        properties: {
+          relatedItem: true,
+          parentId: parentItem._id,
+          parentItemId: parentItem.itemId,
+          mergeWithParentItem: true,
+        },
+      };
+
+      const { updatedOrder } = pricingService.order.addItem({
+        order,
+        item: relatedItem,
+      });
+
+      expect(updatedOrder.items.length).toBe(1);
+      expect(updatedOrder.items[0]._id).toBe('parent-2');
+      expect(updatedOrder.items[0].price).toBe(110);
+      expect(updatedOrder.items[0].name).toBe('Parent - Child');
+      expect(updatedOrder.items[0].modifiers.length).toBe(1);
+      expect(updatedOrder.items[0].modifiers[0].modifierId).toBe('mod-shared');
+    });
   });
 });

package/__TEST__/order/addItem.test.js

@@ -18,6 +18,7 @@ describe('addItem function', () => {
 
     // Mock item to add
     const item = {
+      _id: 'abc',
       itemId: '123',
       quantity: 1,
       price: 100,

package/lib/item/index.js

@@ -74,6 +74,7 @@ const isSerialLengthValid = require('./isSerialLengthValid');
 const getSerialStatus = require('./getSerialStatus');
 const removeDepartmentModifiers = require('./removeDepartmentModifiers');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isMergeWithParentItem = require('./isMergeWithParentItem');
 const hasRelatedItems = require('./hasRelatedItems');
 const getAddModifiers = require('./getAddModifiers');
 const hasAddModifiers = require('./hasAddModifiers');
@@ -168,6 +169,7 @@ const itemActions = (deps = {}) => {
     getSerialStatus: getSerialStatus(innerDeps),
     removeDepartmentModifiers: removeDepartmentModifiers(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     hasRelatedItems: hasRelatedItems(innerDeps),
     getAddModifiers: getAddModifiers(innerDeps),
     hasAddModifiers: hasAddModifiers(innerDeps),

package/lib/item/isMergeWithParentItem.js

@@ -0,0 +1,4 @@
+module.exports = () =>
+  function isMergeWithParentItem(item) {
+    return !!(item && item.properties && item.properties.mergeWithParentItem);
+  };

package/lib/modifier/index.js

@@ -182,6 +182,7 @@ const getCountPerCustomer = require('./getCountPerCustomer');
 const getAmountMultiplier = require('./getAmountMultiplier');
 const isAmountMultiplier = require('./isAmountMultiplier');
 const isRemoveParentItem = require('./isRemoveParentItem');
+const isMergeWithParentItem = require('./isMergeWithParentItem');
 const isTax = require('./isTax');
 
 const modifierActions = (deps = {}) => {
@@ -377,6 +378,7 @@ const modifierActions = (deps = {}) => {
     getAmountMultiplier: getAmountMultiplier(innerDeps),
     isAmountMultiplier: isAmountMultiplier(innerDeps),
     isRemoveParentItem: isRemoveParentItem(innerDeps),
+    isMergeWithParentItem: isMergeWithParentItem(innerDeps),
     isTax: isTax(innerDeps),
   });
 

package/lib/modifier/isMergeWithParentItem.js

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

package/lib/order/addItem.js

@@ -253,7 +253,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       nextItemIndex,
     });
 
-    if (reArrangedOrder && newIndex) {
+    if (reArrangedOrder && newIndex >= 0) {
       nextOrder = { ...reArrangedOrder };
       nextItemIndex = newIndex;
     }
@@ -262,7 +262,7 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
 
     if (combined && pendingItemIndex > -1 && idx !== itemIndex) {
       const idxToRemove = actions.getPendingItemIndex(nextOrder);
-      nextOrder.items.splice(idxToRemove, 1);
+      if (idxToRemove > -1) nextOrder.items.splice(idxToRemove, 1);
     }
 
     nextOrder = actions.addModifiersToParentItem({
@@ -270,10 +270,29 @@ module.exports = ({ actions, itemActions, modifierActions, settings, _ }) => {
       relatedItem: orderItem,
     });
 
+    const relatedItemFromOrder =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: nextItemIndex }) ||
+      nextItem ||
+      orderItem;
+
+    let newItem = relatedItemFromOrder;
+
+    if (itemActions.isMergeWithParentItem(relatedItemFromOrder)) {
+      const result = actions.mergeRelatedItemWithParentItem({
+        order: nextOrder,
+        relatedItem: relatedItemFromOrder,
+        originalItem: item,
+      });
+      nextOrder = result.order;
+      newItem = result.parent;
+    }
+
     return {
       updatedOrder: nextOrder,
-      itemIndex: nextItemIndex,
-      item: nextItem,
+      item: newItem,
+      itemIndex: nextOrder.items.findIndex(
+        eachItem => eachItem._id === newItem._id
+      ),
     };
   };
 };

package/lib/order/index.js

@@ -95,6 +95,7 @@ const setPieces = require('./setPieces');
 const copyItemToParents = require('./copyItemToParents');
 const getItemsWithParents = require('./getItemsWithParents');
 const addModifiersToParentItem = require('./addModifiersToParentItem');
+const mergeRelatedItemWithParentItem = require('./mergeRelatedItemWithParentItem');
 const removeEmptyNotes = require('./removeEmptyNotes');
 const getTaxes = require('./getTaxes');
 const getPickedStatus = require('./getPickedStatus');
@@ -205,6 +206,7 @@ const orderActions = (deps = {}) => {
     copyItemToParents: copyItemToParents(innerDeps),
     getItemsWithParents: getItemsWithParents(innerDeps),
     addModifiersToParentItem: addModifiersToParentItem(innerDeps),
+    mergeRelatedItemWithParentItem: mergeRelatedItemWithParentItem(innerDeps),
     removeEmptyNotes: removeEmptyNotes(innerDeps),
     getTaxes: getTaxes(innerDeps),
     getPickedStatus: getPickedStatus(innerDeps),

package/lib/order/mergeRelatedItemWithParentItem.js

@@ -0,0 +1,94 @@
+module.exports = ({ actions, itemActions, utils }) => {
+  const { math } = utils;
+
+  return function mergeRelatedItemWithParentItem({
+    order,
+    relatedItem,
+    originalItem,
+  }) {
+    if (
+      !order ||
+      !itemActions.isRelatedItem(relatedItem) ||
+      (!itemActions.isMergeWithParentItem(originalItem) &&
+        !itemActions.isMergeWithParentItem(relatedItem))
+    ) {
+      return order;
+    }
+
+    if (!Array.isArray(order.items)) return order;
+
+    const nextOrder = { ...order };
+
+    const parentItem = itemActions.getParentItem(nextOrder.items, relatedItem);
+    if (!parentItem) return nextOrder;
+
+    const parentIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: parentItem,
+    });
+    if (parentIndex < 0) return nextOrder;
+
+    const relatedIndex = actions.getItemIndex({
+      order: nextOrder,
+      item: relatedItem,
+    });
+    if (relatedIndex < 0) return nextOrder;
+
+    let updatedParent = parentItem;
+
+    if (relatedItem && relatedItem.name) {
+      if (!updatedParent.name) updatedParent.name = relatedItem.name;
+      else if (!updatedParent.name.includes(relatedItem.name)) {
+        updatedParent.name = `${updatedParent.name} - ${relatedItem.name}`;
+      }
+    }
+
+    if (typeof relatedItem.price === 'number') {
+      updatedParent.price = math.add(
+        updatedParent.price || 0,
+        relatedItem.price
+      );
+    }
+
+    nextOrder.items = [...nextOrder.items];
+    nextOrder.items[parentIndex] = updatedParent;
+
+    const relatedModifiers = Array.isArray(relatedItem.modifiers)
+      ? relatedItem.modifiers
+      : [];
+
+    if (relatedModifiers.length) {
+      const parentModifierIds = (updatedParent.modifiers || [])
+        .map(mod => mod.modifierId || mod._id)
+        .filter(Boolean);
+
+      const modifiersToAdd = relatedModifiers.filter(mod => {
+        const modId = mod.modifierId || mod._id;
+        return modId && !parentModifierIds.includes(modId);
+      });
+
+      if (modifiersToAdd.length) {
+        const orderWithModifiers = modifiersToAdd.reduce(
+          (acc, modifier) =>
+            actions.addItemModifier({
+              itemIndex: parentIndex,
+              order: acc,
+              modifier,
+              originalItem: updatedParent,
+            }),
+          nextOrder
+        );
+        nextOrder.items = orderWithModifiers.items;
+      }
+    }
+
+    updatedParent =
+      actions.getSelectedItem({ order: nextOrder, itemIndex: parentIndex }) ||
+      updatedParent;
+
+    nextOrder.items[parentIndex] = updatedParent;
+    nextOrder.items.splice(relatedIndex, 1);
+
+    return { order: nextOrder, parent: updatedParent };
+  };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.138",
+  "version": "1.0.139",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -53,5 +53,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "95d90c9dccaf934d7d4a8adc8e46115e90b81664"
+  "gitHead": "643797505f915f1c4562c19e59a82dd98ae888ec"
 }