@darkpos/pricing 1.0.152 → 1.0.154

package/__TEST__/order/applyRefund.test.js

@@ -0,0 +1,387 @@
+const usePricing = require('../../index');
+const mockStores = require('../mocks/stores');
+
+const session = {
+  store: mockStores[0],
+};
+
+const pricingService = usePricing(session);
+
+const createOptions = items => ({
+  'order-1': {
+    items,
+  },
+});
+
+describe('Apply refund', () => {
+  test('keeps applyPayment working for positive amounts', () => {
+    const options = createOptions({
+      'item-1': {
+        total: 8,
+        totalPaid: 0,
+        status: {},
+      },
+      'item-2': {
+        total: 7,
+        totalPaid: 0,
+        status: {},
+      },
+    });
+
+    const result = pricingService.order.applyPayment(options, 10);
+
+    expect(result['order-1'].items['item-1']).toMatchObject({
+      orderId: 'order-1',
+      amount: 8,
+      totalPaid: 8,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result['order-1'].items['item-2']).toMatchObject({
+      orderId: 'order-1',
+      amount: 2,
+      totalPaid: 2,
+      status: {
+        paid: {
+          value: false,
+        },
+      },
+    });
+  });
+
+  test('applies refunds when amount to process is negative', () => {
+    const options = createOptions({
+      'item-1': {
+        total: 8,
+        totalPaid: 8,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      'item-2': {
+        total: 7,
+        totalPaid: 7,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+    });
+
+    const result = pricingService.order.applyRefund(options, -10);
+
+    expect(result.refundedAmount).toBe(10);
+
+    expect(result.options['order-1'].items['item-1']).toMatchObject({
+      orderId: 'order-1',
+      amount: -8,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: false,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items['item-2']).toMatchObject({
+      orderId: 'order-1',
+      amount: -2,
+      totalPaid: 5,
+      status: {
+        paid: {
+          value: false,
+        },
+      },
+    });
+  });
+
+  test('accepts positive refund amounts and only applies the visible overpayment on current items', () => {
+    const options = createOptions({
+      'item-1': {
+        total: 1,
+        totalPaid: 5,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      'item-2': {
+        total: 1,
+        totalPaid: 5,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+    });
+
+    const result = pricingService.order.applyRefund(options, 3);
+
+    expect(result.refundedAmount).toBe(3);
+
+    expect(result.options['order-1'].items['item-1']).toMatchObject({
+      orderId: 'order-1',
+      amount: -3,
+      totalPaid: 2,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items['item-2']).toMatchObject({
+      orderId: 'order-1',
+      amount: 0,
+      totalPaid: 5,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+  });
+
+  test('normalizes overpaid items after refund so no item keeps totalPaid above total', () => {
+    const options = createOptions({
+      '698a364799a15511959c9135': {
+        status: {
+          picked: {
+            value: false,
+            date: '',
+          },
+          paid: {
+            value: true,
+            date: new Date('2026-04-01T16:32:04.514Z'),
+          },
+          tracker: [],
+        },
+        total: 1.05,
+        totalPaid: 14.7,
+      },
+      '698a364799a15511959c9130': {
+        status: {
+          picked: {
+            value: false,
+            date: '',
+          },
+          paid: {
+            value: false,
+            date: new Date('2026-04-01T16:32:04.514Z'),
+          },
+          tracker: [],
+        },
+        total: 1.05,
+        totalPaid: 0,
+      },
+    });
+
+    const result = pricingService.order.applyRefund(options, -12.6);
+
+    expect(result.refundedAmount).toBe(12.6);
+
+    expect(
+      result.options['order-1'].items['698a364799a15511959c9135']
+    ).toMatchObject({
+      orderId: 'order-1',
+      amount: -13.65,
+      totalPaid: 1.05,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(
+      result.options['order-1'].items['698a364799a15511959c9130']
+    ).toMatchObject({
+      orderId: 'order-1',
+      amount: 1.05,
+      totalPaid: 1.05,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+  });
+
+  test('ignores refund amounts larger than the refundable balance', () => {
+    const options = createOptions({
+      'item-1': {
+        total: 8,
+        totalPaid: 8,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      'item-2': {
+        total: 7,
+        totalPaid: 2,
+        status: {
+          paid: {
+            value: false,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+    });
+
+    const result = pricingService.order.applyRefund(options, -100);
+
+    expect(result.refundedAmount).toBe(10);
+
+    expect(result.options['order-1'].items['item-1']).toMatchObject({
+      orderId: 'order-1',
+      amount: -8,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: false,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items['item-2']).toMatchObject({
+      orderId: 'order-1',
+      amount: -2,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: false,
+        },
+      },
+    });
+  });
+
+  test('refunds overpaid zero-total items before touching correctly paid items', () => {
+    const options = createOptions({
+      shorts: {
+        total: 6.3,
+        totalPaid: 6.3,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      jacket1: {
+        total: 0,
+        totalPaid: 8.93,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      longJacket: {
+        total: 0,
+        totalPaid: 12.6,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      jacket2: {
+        total: 0,
+        totalPaid: 8.93,
+        status: {
+          paid: {
+            value: true,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+      coat: {
+        total: 13.65,
+        totalPaid: 3.24,
+        status: {
+          paid: {
+            value: false,
+            date: new Date('2024-01-01T00:00:00.000Z'),
+          },
+        },
+      },
+    });
+
+    const result = pricingService.order.applyRefund(options, 20.05);
+
+    expect(result.refundedAmount).toBe(20.05);
+
+    expect(result.options['order-1'].items.shorts).toMatchObject({
+      orderId: 'order-1',
+      amount: 0,
+      totalPaid: 6.3,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items.jacket1).toMatchObject({
+      orderId: 'order-1',
+      amount: -8.93,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items.longJacket).toMatchObject({
+      orderId: 'order-1',
+      amount: -12.6,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items.jacket2).toMatchObject({
+      orderId: 'order-1',
+      amount: -8.93,
+      totalPaid: 0,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+
+    expect(result.options['order-1'].items.coat).toMatchObject({
+      orderId: 'order-1',
+      amount: 10.41,
+      totalPaid: 13.65,
+      status: {
+        paid: {
+          value: true,
+        },
+      },
+    });
+  });
+});

package/__TEST__/payment.test.js

@@ -62,7 +62,7 @@ describe('getMaxAmountToRefund tests', () => {
 });
 
 describe('getRefundableOrderAmount tests', () => {
-  test('Returns paid amount not attached to current items', () => {
+  test('Returns 0 when retained order payment still matches the remaining item total', () => {
     const order = {
       _id: 'order-1',
       totalPaid: 5,
@@ -77,10 +77,10 @@ describe('getRefundableOrderAmount tests', () => {
       ],
     };
 
-    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(5);
+    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(0);
   });
 
-  test('Returns only the excess from items that actually received payment', () => {
+  test('Returns the net order overpayment (totalPaid minus total), regardless of per-item breakdown', () => {
     const order = {
       _id: 'order-2',
       totalPaid: 14.7,
@@ -103,177 +103,122 @@ describe('getRefundableOrderAmount tests', () => {
     };
 
     expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(
-      13.65
+      12.6
     );
   });
 });
 
-describe('getoverPaidOrders tests', () => {
-  test('Collects refundable child orders from a mixed parent list', () => {
-    const orders = [
-      {
-        _id: 'parent-1',
-        isParent: true,
-        orders: [
-          {
-            _id: 'child-1',
-            totalPaid: 5,
-            items: [
-              {
-                _id: 'item-1',
-                total: 5,
-                totalPaid: 0,
-                status: { paid: { value: false } },
-              },
-            ],
-          },
-          {
-            _id: 'child-2',
-            totalPaid: 5,
-            items: [
-              {
-                _id: 'item-2',
-                total: 5,
-                totalPaid: 5,
-                status: { paid: { value: true } },
-              },
-            ],
-          },
-        ],
-      },
-    ];
+describe('getOverPaidOrders tests', () => {
+  const baseOrder = pricingService.order.calculate({
+    _id: 'order-1',
+    items: [{ price: 30, quantity: 1, modifiers: [] }],
+  });
 
-    expect(pricingService.payment.getOverPaidOrders({ orders })).toEqual({
-      overPaidAmount: 5,
-      overPaidOrders: [
-        {
-          _id: 'child-1',
-          totalPaid: 5,
-          items: [
-            {
-              _id: 'item-1',
-              total: 5,
-              totalPaid: 0,
-              status: { paid: { value: false } },
-            },
-          ],
-          refundableAmount: 5,
-        },
-      ],
+  test('includes order and accumulates overpaid amount when customer paid more than the order total', () => {
+    const order = { ...baseOrder, totalPaid: 50 };
+
+    const result = pricingService.payment.getOverPaidOrders({
+      orders: [order],
     });
+
+    expect(result.overPaidOrders).toHaveLength(1);
+    expect(result.overPaidAmount).toBe(20);
   });
 
-  test('Ignores empty and non-refundable orders', () => {
-    const orders = [
-      null,
-      {
-        _id: 'order-1',
-        totalPaid: 5,
-        items: [
-          {
-            _id: 'item-1',
-            total: 5,
-            totalPaid: 5,
-            status: { paid: { value: true } },
-          },
-        ],
-      },
-      {
-        isParent: true,
-        orders: [
-          {
-            _id: 'child-1',
-            totalPaid: 1,
-            items: [
-              {
-                _id: 'item-2',
-                total: 1,
-                totalPaid: 1,
-                status: { paid: { value: true } },
-              },
-            ],
-          },
-        ],
-      },
-    ];
+  test('returns empty list and zero amount when customer paid exactly the order total', () => {
+    const order = { ...baseOrder, totalPaid: 30 };
 
-    expect(pricingService.payment.getOverPaidOrders({ orders })).toEqual({
-      overPaidAmount: 0,
-      overPaidOrders: [],
+    const result = pricingService.payment.getOverPaidOrders({
+      orders: [order],
     });
+
+    expect(result.overPaidOrders).toHaveLength(0);
+    expect(result.overPaidAmount).toBe(0);
+  });
+
+  test('includes a void order paid exactly to its total as refundable', () => {
+    const order = pricingService.order.voidOrder({
+      ...baseOrder,
+      totalPaid: 30,
+    });
+
+    const result = pricingService.payment.getOverPaidOrders({
+      orders: [order],
+    });
+
+    expect(result.overPaidOrders).toHaveLength(1);
+    expect(result.overPaidOrders[0].refundableAmount).toBe(30);
+    expect(result.overPaidAmount).toBe(30);
   });
 });
 
-describe('getMethodLabel tests', () => {
-  test('Returns the configured label for the payment provider', () => {
-    expect(
-      pricingServiceMethodLabel.payment.getMethodLabel({
-        paymentProvider: 'cash',
-      })
-    ).toBe('Cash');
+describe('capOverPaidItem tests', () => {
+  test('caps totalPaid to item total and returns the excess as amountCapped', () => {
+    const item = { total: 10, totalPaid: 15 };
+
+    const result = pricingService.item.capOverPaidItem({ item });
+
+    expect(result.item.totalPaid).toBe(10);
+    expect(result.amountCapped).toBe(5);
   });
 
-  test('Returns empty string when the provider is missing', () => {
-    expect(
-      pricingServiceMethodLabel.payment.getMethodLabel({
-        paymentProvider: 'missing-provider',
-      })
-    ).toBe('');
+  test('returns item unchanged and amountCapped 0 when totalPaid does not exceed total', () => {
+    const item = { total: 10, totalPaid: 10 };
+
+    const result = pricingService.item.capOverPaidItem({ item });
+
+    expect(result.item.totalPaid).toBe(10);
+    expect(result.amountCapped).toBe(0);
   });
 });
 
-describe('appendIfOverPaid tests', () => {
-  test('Appends the order with refundableAmount when the order is overpaid', () => {
-    const currentOrder = {
+describe('getTotalPaidToRedistribute tests', () => {
+  test('returns order with redistributableAmount when totalPaid exceeds item totalPaid sum', () => {
+    const order = {
       _id: 'order-1',
-      displayId: '101',
       totalPaid: 5,
-      items: [
-        {
-          _id: 'item-2',
-          name: 'Simple Item 2',
-          total: 5,
-          totalPaid: 0,
-          status: { paid: { value: false } },
-        },
-      ],
+      items: [{ totalPaid: 0 }, { totalPaid: 0 }],
     };
 
-    expect(
-      pricingService.payment.appendIfOverPaid({
-        currentOrder,
-        overPaidOrders: [{ _id: 'existing-order', refundableAmount: 1 }],
-      })
-    ).toEqual([
-      { _id: 'existing-order', refundableAmount: 1 },
-      {
-        ...currentOrder,
-        refundableAmount: 5,
-      },
-    ]);
+    const result = pricingService.order.getTotalPaidToRedistribute({
+      orders: [order],
+    });
+
+    expect(result.redistributableOrders).toHaveLength(1);
+    expect(result.redistributableOrders[0].redistributableAmount).toBe(5);
+    expect(result.redistributableAmount).toBe(5);
   });
 
-  test('Leaves the collection unchanged when the order has no refundable amount', () => {
-    const overPaidOrders = [{ _id: 'existing-order', refundableAmount: 1 }];
-    const currentOrder = {
-      _id: 'order-3',
-      totalPaid: 5,
-      items: [
-        {
-          _id: 'item-1',
-          name: 'Simple Item 1',
-          total: 5,
-          totalPaid: 5,
-          status: { paid: { value: true } },
-        },
-      ],
+  test('returns empty list and zero amount when all totalPaid is already distributed to items', () => {
+    const order = {
+      _id: 'order-1',
+      totalPaid: 10,
+      items: [{ totalPaid: 6 }, { totalPaid: 4 }],
     };
 
+    const result = pricingService.order.getTotalPaidToRedistribute({
+      orders: [order],
+    });
+
+    expect(result.redistributableOrders).toHaveLength(0);
+    expect(result.redistributableAmount).toBe(0);
+  });
+});
+
+describe('getMethodLabel tests', () => {
+  test('Returns the configured label for the payment provider', () => {
     expect(
-      pricingService.payment.appendIfOverPaid({
-        currentOrder,
-        overPaidOrders,
+      pricingServiceMethodLabel.payment.getMethodLabel({
+        paymentProvider: 'cash',
       })
-    ).toEqual(overPaidOrders);
+    ).toBe('Cash');
+  });
+
+  test('Returns empty string when the provider is missing', () => {
+    expect(
+      pricingServiceMethodLabel.payment.getMethodLabel({
+        paymentProvider: 'missing-provider',
+      })
+    ).toBe('');
   });
 });

package/lib/invoice/index.js

@@ -1,7 +1,5 @@
 const getStatusByItems = require('./getStatusByItems');
 const getTotalByItems = require('./getTotalByItems');
-const resolveItemState = require('./resolveItemState');
-const computeRefundables = require('./computeRefundables');
 
 const invoiceActions = (deps = {}) => {
   const actions = {};
@@ -14,8 +12,6 @@ const invoiceActions = (deps = {}) => {
   const freezedActions = Object.freeze({
     getStatusByItems: getStatusByItems(innerDeps),
     getTotalByItems: getTotalByItems(innerDeps),
-    resolveItemState: resolveItemState(innerDeps),
-    computeRefundables: computeRefundables(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/item/capOverPaidItem.js

@@ -0,0 +1,14 @@
+module.exports = ({ utils }) =>
+  function capOverPaidItem({ item }) {
+    const total = item.total || 0;
+
+    const totalPaid = item.totalPaid || 0;
+
+    if (totalPaid > total)
+      return {
+        item: { ...item, totalPaid: total },
+        amountCapped: utils.math.sub(totalPaid, total),
+      };
+
+    return { item, amountCapped: 0 };
+  };

package/lib/item/index.js

@@ -84,6 +84,7 @@ const getAmountToPayById = require('./getAmountToPayById');
 const applyPayment = require('./applyPayment');
 const getBalanceForPaymentModifier = require('./getBalanceForPaymentModifier');
 const isOverpaid = require('./isOverpaid');
+const capOverPaidItem = require('./capOverPaidItem');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -181,6 +182,7 @@ const itemActions = (deps = {}) => {
     applyPayment: applyPayment(innerDeps),
     getBalanceForPaymentModifier: getBalanceForPaymentModifier(innerDeps),
     isOverpaid: isOverpaid(innerDeps),
+    capOverPaidItem: capOverPaidItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/applyRefund.js

@@ -0,0 +1,125 @@
+module.exports = ({ utils, actions }) =>
+  function applyRefund(options, amountToProcess = 0) {
+    const optionsWithAmount = options;
+    let amount = Math.abs(amountToProcess || 0);
+    let refundedAmount = 0;
+
+    Object.keys(options).forEach(orderId => {
+      const order = options[orderId];
+      const { items } = order;
+      const itemIds = Object.keys(items);
+
+      itemIds.forEach(itemId => {
+        const item = items[itemId];
+
+        items[itemId] = {
+          ...item,
+          orderId,
+          amount: item.amount || 0,
+        };
+      });
+
+      itemIds.forEach(itemId => {
+        if (amount <= 0) return;
+
+        const item = items[itemId];
+        const overPaidAmount = utils.math.max(
+          utils.math.sub(item.totalPaid || 0, item.total || 0),
+          0
+        );
+        const { refunded, item: updatedItem } = actions.refundOrderItem({
+          item,
+          orderId,
+          amountToRefund: utils.math.min(amount, overPaidAmount),
+        });
+
+        if (!updatedItem) return;
+
+        refundedAmount = utils.math.add(refundedAmount, refunded);
+        items[itemId] = updatedItem;
+        amount = utils.math.sub(amount, refunded);
+      });
+
+      itemIds.forEach(itemId => {
+        if (amount <= 0) return;
+
+        const item = items[itemId];
+        const { refunded, item: updatedItem } = actions.refundOrderItem({
+          item,
+          orderId,
+          amountToRefund: amount,
+        });
+
+        if (!updatedItem) return;
+
+        refundedAmount = utils.math.add(refundedAmount, refunded);
+        items[itemId] = updatedItem;
+        amount = utils.math.sub(amount, refunded);
+      });
+
+      itemIds.forEach((itemId, index) => {
+        const item = items[itemId];
+        let excess = utils.math.max(
+          utils.math.sub(item.totalPaid || 0, item.total || 0),
+          0
+        );
+
+        if (excess <= 0) return;
+
+        for (
+          let nextIndex = index + 1;
+          nextIndex < itemIds.length;
+          nextIndex += 1
+        ) {
+          if (excess <= 0) break;
+
+          const nextItemId = itemIds[nextIndex];
+          const nextItem = items[nextItemId];
+          const capacity = utils.math.max(
+            utils.math.sub(nextItem.total || 0, nextItem.totalPaid || 0),
+            0
+          );
+          const amountToMove = utils.math.min(excess, capacity);
+
+          if (amountToMove > 0) {
+            items[itemId] = {
+              ...items[itemId],
+              amount: utils.math.sub(items[itemId].amount || 0, amountToMove),
+              totalPaid: utils.math.sub(
+                items[itemId].totalPaid || 0,
+                amountToMove
+              ),
+            };
+
+            items[nextItemId] = {
+              ...nextItem,
+              amount: utils.math.add(nextItem.amount || 0, amountToMove),
+              totalPaid: utils.math.add(nextItem.totalPaid || 0, amountToMove),
+            };
+
+            excess = utils.math.sub(excess, amountToMove);
+          }
+        }
+      });
+
+      itemIds.forEach(itemId => {
+        const item = items[itemId];
+
+        items[itemId] = {
+          ...item,
+          status: {
+            ...item.status,
+            paid: {
+              value: (item.totalPaid || 0) >= (item.total || 0),
+              date: new Date(),
+            },
+          },
+        };
+      });
+    });
+
+    return {
+      options: optionsWithAmount,
+      refundedAmount,
+    };
+  };

package/lib/order/getOverPaidAmount.js

@@ -0,0 +1,13 @@
+module.exports = ({ itemActions, utils }) =>
+  function getOverPaidAmount({ order }) {
+    if (!order) return 0;
+
+    const { total: itemsTotal } = itemActions.getItemsTotals(order.items || []);
+
+    const orderTotalPaid = order.totalPaid || 0;
+
+    if (orderTotalPaid > itemsTotal)
+      return utils.math.sub(orderTotalPaid, itemsTotal);
+
+    return 0;
+  };

package/lib/order/getTotalPaidToRedistribute.js

@@ -0,0 +1,41 @@
+module.exports = ({ itemActions, utils }) =>
+  function getTotalPaidToRedistribute({ orders = [] }) {
+    const redistributableOrders = [];
+    let redistributableAmount = 0;
+
+    const appendIfRedistributable = currentOrder => {
+      const itemsTotalPaid = itemActions.getItemsTotalPaid({
+        orderItems: currentOrder.items || [],
+      });
+
+      const amount = utils.math.max(
+        utils.math.sub(currentOrder.totalPaid || 0, itemsTotalPaid),
+        0
+      );
+
+      if (amount > 0) {
+        redistributableOrders.push({
+          ...currentOrder,
+          redistributableAmount: amount,
+        });
+        redistributableAmount = utils.math.add(redistributableAmount, amount);
+      }
+    };
+
+    (orders || []).forEach(order => {
+      if (!order || !order._id) return;
+      if (order.isParent) {
+        const childOrders = order.orders || [];
+        if (childOrders.length > 0) {
+          childOrders.forEach(appendIfRedistributable);
+          return;
+        }
+      }
+      appendIfRedistributable(order);
+    });
+
+    return {
+      redistributableOrders,
+      redistributableAmount,
+    };
+  };

package/lib/order/index.js

@@ -82,6 +82,7 @@ const createSubOrder = require('./createSubOrder');
 const manualSplit = require('./manualSplit');
 const manualSplitByQuantity = require('./manualSplitByQuantity');
 const applyPayment = require('./applyPayment');
+const applyRefund = require('./applyRefund');
 const getBalance = require('./getBalance');
 const getLastLocation = require('./getLastLocation');
 const getModifierRelations = require('./getModifierRelations');
@@ -101,6 +102,9 @@ const getTaxes = require('./getTaxes');
 const getPickedStatus = require('./getPickedStatus');
 const calculateWithPayment = require('./calculateWithPayment');
 const hasSerial = require('./hasSerial');
+const getOverPaidAmount = require('./getOverPaidAmount');
+const getTotalPaidToRedistribute = require('./getTotalPaidToRedistribute');
+const refundOrderItem = require('./refundOrderItem');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -194,6 +198,7 @@ const orderActions = (deps = {}) => {
     manualSplit: manualSplit(innerDeps),
     manualSplitByQuantity: manualSplitByQuantity(innerDeps),
     applyPayment: applyPayment(innerDeps),
+    applyRefund: applyRefund(innerDeps),
     getOrdersBalance: getOrdersBalance(innerDeps),
     getLastLocation: getLastLocation(innerDeps),
     getModifierRelations: getModifierRelations(innerDeps),
@@ -213,6 +218,9 @@ const orderActions = (deps = {}) => {
     getPickedStatus: getPickedStatus(innerDeps),
     calculateWithPayment: calculateWithPayment(innerDeps),
     hasSerial: hasSerial(innerDeps),
+    getOverPaidAmount: getOverPaidAmount(innerDeps),
+    getTotalPaidToRedistribute: getTotalPaidToRedistribute(innerDeps),
+    refundOrderItem: refundOrderItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/lib/order/refundOrderItem.js

@@ -0,0 +1,29 @@
+module.exports = ({ utils }) =>
+  function refundOrderItem({ item, orderId, amountToRefund = 0 }) {
+    if (amountToRefund <= 0) return { refunded: 0 };
+
+    const refundableAmount = item.totalPaid || 0;
+    const refunded = utils.math.min(amountToRefund, refundableAmount);
+    const amountToAssign = utils.math.sub(0, refunded);
+    const updatedTotalPaid = utils.math.add(
+      item.totalPaid || 0,
+      amountToAssign
+    );
+
+    return {
+      refunded,
+      item: {
+        ...item,
+        orderId,
+        amount: utils.math.add(item.amount || 0, amountToAssign),
+        totalPaid: updatedTotalPaid,
+        status: {
+          ...item.status,
+          paid: {
+            value: updatedTotalPaid >= (item.total || 0),
+            date: new Date(),
+          },
+        },
+      },
+    };
+  };

package/lib/payment/getOverPaidOrders.js

@@ -1,13 +1,23 @@
-module.exports = ({ actions }) =>
+module.exports = ({ orderActions, utils }) =>
   function getOverPaidOrders({ orders = [] }) {
-    let overPaidOrders = [];
+    const overPaidOrders = [];
     let overPaidAmount = 0;
 
-    const appendIfOverPaid = currentOrder => {
-      overPaidOrders = actions.appendIfOverPaid({
-        currentOrder,
-        overPaidOrders,
+    const appendIfRefundable = currentOrder => {
+      const overPaidTotal = orderActions.getOverPaidAmount({
+        order: currentOrder,
       });
+      const refundableAmount = orderActions.isVoid(currentOrder)
+        ? currentOrder.totalPaid || 0
+        : overPaidTotal;
+
+      if (refundableAmount > 0) {
+        overPaidOrders.push({
+          ...currentOrder,
+          refundableAmount,
+        });
+        overPaidAmount = utils.math.add(overPaidAmount, refundableAmount);
+      }
     };
 
     (orders || []).forEach(order => {
@@ -16,19 +26,14 @@ module.exports = ({ actions }) =>
         const childOrders = order.orders || [];
 
         if (childOrders.length > 0) {
-          childOrders.forEach(appendIfOverPaid);
+          childOrders.forEach(appendIfRefundable);
           return;
         }
       }
 
-      appendIfOverPaid(order);
+      appendIfRefundable(order);
     });
 
-    overPaidAmount = overPaidOrders.reduce(
-      (total, order) => total + Number(order.refundableAmount || 0),
-      0
-    );
-
     return {
       overPaidOrders,
       overPaidAmount,

package/lib/payment/getRefundableOrderAmount.js

@@ -5,30 +5,17 @@ module.exports = ({ utils }) => {
     if (!order) return 0;
 
     const items = Array.isArray(order.items) ? order.items : [];
-    const paidItems = items.filter(item => Number(item.totalPaid || 0) > 0);
+    const orderTotal =
+      typeof order.total === 'number'
+        ? order.total
+        : items.reduce(
+            (acc, item) => math.add(acc, Number(item.total || 0)),
+            0
+          );
 
-    const itemsTotalPaid = items.reduce(
-      (acc, item) => math.add(acc, Number(item.totalPaid || 0)),
+    return math.max(
+      math.sub(Number(order.totalPaid || 0), Number(orderTotal || 0)),
       0
     );
-    const paidItemsTotalPaid = paidItems.reduce(
-      (acc, item) => math.add(acc, Number(item.totalPaid || 0)),
-      0
-    );
-    const paidItemsTotal = paidItems.reduce(
-      (acc, item) => math.add(acc, Number(item.total || 0)),
-      0
-    );
-
-    const orphanedPaidAmount = math.max(
-      math.sub(order.totalPaid || 0, itemsTotalPaid),
-      0
-    );
-    const refundablePaidItemsAmount = math.max(
-      math.sub(paidItemsTotalPaid, paidItemsTotal),
-      0
-    );
-
-    return math.add(orphanedPaidAmount, refundablePaidItemsAmount);
   };
 };

package/lib/payment/index.js

@@ -1,9 +1,8 @@
 //
-const appendIfOverPaid = require('./appendIfOverPaid');
 const getMaxAmountToRefund = require('./getMaxAmountToRefund');
 const getRefundableOrderAmount = require('./getRefundableOrderAmount');
-const getOverPaidOrders = require('./getOverPaidOrders');
 const getMethodLabel = require('./getMethodLabel');
+const getOverPaidOrders = require('./getOverPaidOrders');
 
 const orderActions = (deps = {}) => {
   const actions = {};
@@ -14,11 +13,10 @@ const orderActions = (deps = {}) => {
   };
 
   const freezedActions = Object.freeze({
-    appendIfOverPaid: appendIfOverPaid(innerDeps),
     getMaxAmountToRefund: getMaxAmountToRefund(innerDeps),
     getRefundableOrderAmount: getRefundableOrderAmount(innerDeps),
-    getOverPaidOrders: getOverPaidOrders(innerDeps),
     getMethodLabel: getMethodLabel(innerDeps),
+    getOverPaidOrders: getOverPaidOrders(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.152",
+  "version": "1.0.154",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -54,5 +54,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "1dff1f50b45bf68bd10e8d8ef7fe18c2b37c751e"
+  "gitHead": "6d06392dd10f6fba50228db77331e4073cf2e3bf"
 }

package/__TEST__/invoice/refundInvoices.test.js

@@ -1,106 +0,0 @@
-const usePricing = require('../../index');
-const mockStores = require('../mocks/stores');
-
-const pricing = usePricing({ store: mockStores[0] });
-
-const ORDER_ID = 'order-1';
-const OVERPAID_ITEM_ID = 'item-0';
-const UNDERPAID_ITEM_ID = 'item-1';
-
-const liveOrder = {
-  _id: ORDER_ID,
-  items: [
-    {
-      _id: OVERPAID_ITEM_ID,
-      total: 10.5,
-      totalPaid: 14.7,
-      status: { paid: { value: true }, picked: { value: false } },
-    },
-    {
-      _id: UNDERPAID_ITEM_ID,
-      total: 10.5,
-      totalPaid: 10.3,
-      status: { paid: { value: false }, picked: { value: false } },
-    },
-  ],
-};
-
-const ordersById = { [ORDER_ID]: liveOrder };
-
-const overpaidInvoiceItem = {
-  orderId: ORDER_ID,
-  orderItemId: OVERPAID_ITEM_ID,
-  total: 14.7,
-  totalPaid: 14.7,
-  amount: 14.7,
-  status: { paid: { value: true }, picked: { value: false } },
-};
-
-const partiallyPaidInvoiceItem = {
-  orderId: ORDER_ID,
-  orderItemId: UNDERPAID_ITEM_ID,
-  total: 13.65,
-  totalPaid: 10.3,
-  amount: 10.3,
-  status: { paid: { value: false }, picked: { value: false } },
-};
-
-describe('computeRefundables', () => {
-  const overpaidState = pricing.invoice.resolveItemState(
-    overpaidInvoiceItem,
-    ordersById
-  ); // excess +4.2
-  const underpaidState = pricing.invoice.resolveItemState(
-    partiallyPaidInvoiceItem,
-    ordersById
-  ); // excess -0.2
-
-  test('refunds the full excess from the overpaid item and redistributes the surplus to the underpaid item', () => {
-    const [overpaidRefundable, underpaidCredit] =
-      pricing.invoice.computeRefundables([overpaidState, underpaidState], 4);
-    expect(overpaidRefundable).toBe(4.2); // full overpayment cleared
-    expect(underpaidCredit).toBe(-0.2); // 0.2 credit applied to cover the gap
-  });
-
-  test('net refund amount across all items equals the requested refund total', () => {
-    const [overpaidRefundable, underpaidCredit] =
-      pricing.invoice.computeRefundables([overpaidState, underpaidState], 4);
-    expect(overpaidRefundable + underpaidCredit).toBe(4);
-  });
-
-  test('result is order-independent — same outcome when items are reversed', () => {
-    const [underpaidCredit, overpaidRefundable] =
-      pricing.invoice.computeRefundables([underpaidState, overpaidState], 4);
-    expect(overpaidRefundable).toBe(4.2);
-    expect(underpaidCredit).toBe(-0.2);
-  });
-
-  test('never-paid item receives no credit even when overpaid surplus exists', () => {
-    const neverPaidState = {
-      ...pricing.invoice.resolveItemState(partiallyPaidInvoiceItem, ordersById),
-      itemTotalPaid: 0,
-      excess: -10.5,
-    };
-    const [overpaidRefundable, neverPaidRefundable] =
-      pricing.invoice.computeRefundables([overpaidState, neverPaidState], 4);
-    expect(overpaidRefundable).toBe(4); // capped — no surplus to redistribute
-    expect(neverPaidRefundable).toBe(0); // never-paid item stays untouched
-  });
-
-  test('draws directly from totalPaid when no overpaid items exist', () => {
-    const exactlyPaidState = { ...overpaidState, excess: 0 };
-    const [refundable] = pricing.invoice.computeRefundables(
-      [exactlyPaidState],
-      5
-    );
-    expect(refundable).toBe(5);
-  });
-
-  test('returns all zeros when the requested refund amount is 0', () => {
-    const refundables = pricing.invoice.computeRefundables(
-      [overpaidState, underpaidState],
-      0
-    );
-    expect(refundables).toEqual([0, 0]);
-  });
-});

package/lib/invoice/computeRefundables.js

@@ -1,59 +0,0 @@
-module.exports = ({ utils }) => {
-  const { math } = utils;
-
-  return function computeRefundables(itemStates, totalToRefund) {
-    const refundables = new Array(itemStates.length).fill(0);
-
-    if (totalToRefund <= 0) return refundables;
-
-    // Only partially-paid underpaid items are eligible to absorb redistribution credits.
-    const eligibleDeficit = itemStates.reduce(
-      (sum, { excess, itemTotalPaid }) => {
-        const isPartiallyPaidAndUnderpaid = excess < 0 && itemTotalPaid > 0;
-        return isPartiallyPaidAndUnderpaid
-          ? math.add(sum, math.sub(0, excess))
-          : sum;
-      },
-      0
-    );
-
-    // Cap total drawn from overpaid items so the net refund never exceeds totalToRefund.
-    let maxFromOverpaid = math.add(totalToRefund, eligibleDeficit);
-    let tempRemaining = totalToRefund;
-
-    // Pass 1: refund each overpaid item's excess, capped by maxFromOverpaid
-    itemStates.forEach(({ excess }, i) => {
-      if (excess > 0 && maxFromOverpaid > 0) {
-        const refund = excess > maxFromOverpaid ? maxFromOverpaid : excess;
-        refundables[i] = refund;
-        tempRemaining = math.sub(tempRemaining, refund);
-        maxFromOverpaid = math.sub(maxFromOverpaid, refund);
-      }
-    });
-
-    if (tempRemaining < 0) {
-      // Pass 2a: over-refunded — spread surplus as credits to partially-paid underpaid items
-      let surplus = math.sub(0, tempRemaining);
-      itemStates.forEach(({ excess, itemTotalPaid }, i) => {
-        if (excess < 0 && itemTotalPaid > 0 && surplus > 0) {
-          const deficit = math.sub(0, excess);
-          const credit = surplus > deficit ? deficit : surplus;
-          refundables[i] = -credit;
-          surplus = math.sub(surplus, credit);
-        }
-      });
-    } else if (tempRemaining > 0) {
-      // Pass 2b: under-refunded — draw remainder from non-overpaid items (totalPaid > 0)
-      itemStates.forEach(({ itemTotalPaid, excess }, i) => {
-        if (excess <= 0 && itemTotalPaid > 0 && tempRemaining > 0) {
-          const refund =
-            tempRemaining > itemTotalPaid ? itemTotalPaid : tempRemaining;
-          refundables[i] = refund;
-          tempRemaining = math.sub(tempRemaining, refund);
-        }
-      });
-    }
-
-    return refundables;
-  };
-};

package/lib/invoice/resolveItemState.js

@@ -1,25 +0,0 @@
-module.exports = ({ utils }) => {
-  const { math } = utils;
-
-  return function resolveItemState(paymentOrderItem, ordersById) {
-    const order = (ordersById && ordersById[paymentOrderItem.orderId]) || {};
-    const orderItem = (order.items || []).find(
-      each => each._id === paymentOrderItem.orderItemId
-    );
-
-    const itemTotal = orderItem ? orderItem.total : paymentOrderItem.total || 0;
-    const itemTotalPaid = orderItem
-      ? orderItem.totalPaid
-      : paymentOrderItem.totalPaid || 0;
-    const currentStatus =
-      (orderItem && orderItem.status) || paymentOrderItem.status || {};
-
-    return {
-      item: paymentOrderItem,
-      itemTotal,
-      itemTotalPaid,
-      currentStatus,
-      excess: math.sub(itemTotalPaid, itemTotal),
-    };
-  };
-};

package/lib/payment/appendIfOverPaid.js

@@ -1,17 +0,0 @@
-module.exports = ({ actions }) =>
-  function appendIfOverPaid({ currentOrder, overPaidOrders = [] }) {
-    if (!currentOrder || !currentOrder._id) return overPaidOrders;
-
-    const refundableAmount = actions.getRefundableOrderAmount({
-      order: currentOrder,
-    });
-    if (refundableAmount <= 0) return overPaidOrders;
-
-    return [
-      ...overPaidOrders,
-      {
-        ...currentOrder,
-        refundableAmount,
-      },
-    ];
-  };