@darkpos/pricing 1.0.151 → 1.0.153

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__/order/order-payment-modifier.test.js

@@ -574,9 +574,11 @@ describe('Order actions', () => {
       lockPaymentModifiers: true,
     });
 
+    paidOrderWithCredit.totalPaid += 1.25;
     const orderBalanceWithCredit = pricingService.order.getOrdersBalance({
       orders: [paidOrderWithCredit],
     });
+
     const itemBalanceWithCredit = pricingService.item.getItemsBalance({
       items: paidOrderWithCredit.items,
     });

package/__TEST__/order/order.test.js

@@ -3818,7 +3818,7 @@ describe('Order actions', () => {
     const pricing = usePricing({
       store: { _settings: { order: { autoMarkAsPaid: false } } },
     });
-    const order = { items: [orderItem], status: {} };
+    const order = { items: [orderItem], status: {}, totalPaid: 30 };
     const newOrder = pricing.order.calculate(order);
 
     expect(newOrder).toHaveProperty('total', 25);

package/__TEST__/payment.test.js

@@ -6,6 +6,17 @@ const session = {
 };
 
 const pricingService = usePricing(session);
+const pricingServiceMethodLabel = usePricing({
+  store: {
+    _settings: {
+      _settings: {
+        payment: {
+          methods: mockStores[0]._settings.payment.methods,
+        },
+      },
+    },
+  },
+});
 
 describe('getMaxAmountToRefund tests', () => {
   test('Returns 0 when payment is undefined', () => {
@@ -49,3 +60,150 @@ describe('getMaxAmountToRefund tests', () => {
     expect(pricingService.payment.getMaxAmountToRefund({ payment })).toBe(50);
   });
 });
+
+describe('getRefundableOrderAmount tests', () => {
+  test('Returns 0 when retained order payment still matches the remaining item total', () => {
+    const order = {
+      _id: 'order-1',
+      totalPaid: 5,
+      items: [
+        {
+          _id: 'item-2',
+          name: 'Simple Item 2',
+          total: 5,
+          totalPaid: 0,
+          status: { paid: { value: false } },
+        },
+      ],
+    };
+
+    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(0);
+  });
+
+  test('Returns the net order overpayment (totalPaid minus total), regardless of per-item breakdown', () => {
+    const order = {
+      _id: 'order-2',
+      totalPaid: 14.7,
+      items: [
+        {
+          _id: 'item-1',
+          name: 'Winter Coat',
+          total: 1.05,
+          totalPaid: 14.7,
+          status: { paid: { value: true } },
+        },
+        {
+          _id: 'item-2',
+          name: 'Coat',
+          total: 1.05,
+          totalPaid: 0,
+          status: { paid: { value: false } },
+        },
+      ],
+    };
+
+    expect(pricingService.payment.getRefundableOrderAmount({ order })).toBe(
+      12.6
+    );
+  });
+});
+
+describe('getOverPaidOrders tests', () => {
+  const baseOrder = pricingService.order.calculate({
+    _id: 'order-1',
+    items: [{ price: 30, quantity: 1, modifiers: [] }],
+  });
+
+  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('returns empty list and zero amount when customer paid exactly the order total', () => {
+    const order = { ...baseOrder, totalPaid: 30 };
+
+    const result = pricingService.payment.getOverPaidOrders({
+      orders: [order],
+    });
+
+    expect(result.overPaidOrders).toHaveLength(0);
+    expect(result.overPaidAmount).toBe(0);
+  });
+});
+
+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 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('getTotalPaidToRedistribute tests', () => {
+  test('returns order with redistributableAmount when totalPaid exceeds item totalPaid sum', () => {
+    const order = {
+      _id: 'order-1',
+      totalPaid: 5,
+      items: [{ totalPaid: 0 }, { totalPaid: 0 }],
+    };
+
+    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('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(
+      pricingServiceMethodLabel.payment.getMethodLabel({
+        paymentProvider: 'cash',
+      })
+    ).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,9 +1,5 @@
 const getStatusByItems = require('./getStatusByItems');
 const getTotalByItems = require('./getTotalByItems');
-const resolveItemState = require('./resolveItemState');
-const computeRefundables = require('./computeRefundables');
-const buildItemRefund = require('./buildItemRefund');
-const applyRefundToInvoices = require('./applyRefundToInvoices');
 
 const invoiceActions = (deps = {}) => {
   const actions = {};
@@ -16,10 +12,6 @@ const invoiceActions = (deps = {}) => {
   const freezedActions = Object.freeze({
     getStatusByItems: getStatusByItems(innerDeps),
     getTotalByItems: getTotalByItems(innerDeps),
-    resolveItemState: resolveItemState(innerDeps),
-    computeRefundables: computeRefundables(innerDeps),
-    buildItemRefund: buildItemRefund(innerDeps),
-    applyRefundToInvoices: applyRefundToInvoices(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,7 +84,7 @@ const getAmountToPayById = require('./getAmountToPayById');
 const applyPayment = require('./applyPayment');
 const getBalanceForPaymentModifier = require('./getBalanceForPaymentModifier');
 const isOverpaid = require('./isOverpaid');
-const getOverpaidAmount = require('./getOverpaidAmount');
+const capOverPaidItem = require('./capOverPaidItem');
 
 const itemActions = (deps = {}) => {
   const actions = {};
@@ -182,7 +182,7 @@ const itemActions = (deps = {}) => {
     applyPayment: applyPayment(innerDeps),
     getBalanceForPaymentModifier: getBalanceForPaymentModifier(innerDeps),
     isOverpaid: isOverpaid(innerDeps),
-    getOverpaidAmount: getOverpaidAmount(innerDeps),
+    capOverPaidItem: capOverPaidItem(innerDeps),
   });
 
   Object.keys(freezedActions).forEach(actionName => {