@darkpos/pricing 1.0.31 → 1.0.32

package/__TEST__/item/addIndirectModifier.test.js

@@ -0,0 +1,192 @@
+const _ = require('lodash');
+const utils = require('@darkpos/utils');
+const addIndirectModifierFunction = require('../../lib/item/addIndirectModifier');
+
+describe('addIndirectModifier Function', () => {
+  const modifierActions = {
+    calculate: jest.fn(),
+    createIndirectModifier: jest.fn(),
+  };
+
+  const getComputeModField = jest.fn();
+  // const modifierActions = makeModifierActions(deps);
+
+  const addIndirectModifier = addIndirectModifierFunction({
+    utils,
+    modifierActions,
+    _,
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should correctly distribute modifier across items when totals match', () => {
+    const modifier = {
+      modifier: { type: 'non-credit', action: 'add', amount: 50 },
+    };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 25 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: 25 },
+        properties: {},
+      },
+      item2: {
+        compute: { amount: 50 },
+        properties: {},
+      },
+    });
+  });
+
+  test('should adjust the modifier on one item when totals do not match', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 20 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: 50 }, // Adjusted amount to fix the total distribution difference
+        properties: { ignoreQuantity: true },
+      },
+      item2: { compute: { amount: 50 }, properties: {} },
+    });
+  });
+
+  test('should not adjust the modifier if compute type is percentage and modifier is not credit', () => {
+    const modifier = {
+      modifier: { type: 'non-credit' },
+    };
+    const items = [
+      {
+        _id: 'item1',
+        total: 50,
+        quantity: 2,
+        compute: { type: 'percentage', amount: 10, action: '' },
+      },
+      {
+        _id: 'item2',
+        total: 50,
+        quantity: 1,
+        compute: { type: 'percentage', amount: 10, action: '' },
+      },
+    ];
+    const orderTotal = 100;
+
+    getComputeModField.mockReturnValueOnce({ type: 'percentage' });
+    modifierActions.calculate
+      .mockReturnValueOnce({
+        compute: { amount: 20 },
+        properties: {},
+        _computed: { amount: 15 },
+      })
+      .mockReturnValueOnce({
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({
+        compute: { amount: 20 },
+        properties: {},
+        _computed: { amount: 15 },
+      })
+      .mockReturnValueOnce({
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: -35 },
+        properties: {
+          ignoreQuantity: true,
+        },
+        _computed: { amount: 15 },
+      },
+      item2: {
+        compute: { amount: 50 },
+        properties: {},
+        _computed: { amount: 20 },
+      },
+    });
+  });
+
+  test('should return itemsModifiers as is if totalDistributed equals orderModifierTotal', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 50, quantity: 2 },
+      { _id: 'item2', total: 50, quantity: 1 },
+    ];
+    const orderTotal = 100;
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 25 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 50 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: {
+        compute: { amount: -30 },
+        properties: {
+          ignoreQuantity: true,
+        },
+      },
+      item2: { compute: { amount: 50 }, properties: {} },
+    });
+  });
+
+  test('should not modify any items if totalDistributed exceeds orderModifierTotal and no item can cover the difference', () => {
+    const modifier = { modifier: { type: 'non-credit' } };
+    const items = [
+      { _id: 'item1', total: 10, quantity: 1 },
+      { _id: 'item2', total: 10, quantity: 1 },
+    ];
+    const orderTotal = 20;
+
+    modifierActions.calculate.mockReturnValueOnce({
+      _computed: { amount: 100 },
+    });
+    modifierActions.createIndirectModifier
+      .mockReturnValueOnce({ compute: { amount: 40 }, properties: {} })
+      .mockReturnValueOnce({ compute: { amount: 40 }, properties: {} });
+
+    const result = addIndirectModifier({ orderTotal, items, modifier });
+
+    expect(result).toEqual({
+      item1: { compute: { amount: 40 }, properties: {} },
+      item2: { compute: { amount: 40 }, properties: {} },
+    });
+  });
+});

package/__TEST__/modifier/calculate.test.js

@@ -1,5 +1,6 @@
 const usePricing = require('../../index');
 
+const { getComputeModField } = require('../../lib/modifier/utils');
 const pricingService = usePricing();
 
 describe('Calculate Function', () => {
@@ -13,7 +14,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: 10,
       description: 'someModifier ($10.00)',
@@ -30,7 +34,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: -10,
       description: 'someModifier (-$10.00)',
@@ -47,7 +54,10 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: -6,
       description: 'someModifier (-$6.00)',
@@ -64,10 +74,31 @@ describe('Calculate Function', () => {
       name: 'someModifier',
     };
     const orderItem = { price: 30, quantity: 1 };
-    const computedModifier = pricingService.modifier.calculate(modifier, orderItem);
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
     expect(computedModifier._computed).toMatchObject({
       amount: 6,
       description: 'someModifier ($6.00)',
     });
   });
+
+  test('calculate with a null modifier', () => {
+    const modifier = {
+      compute: null,
+      name: 'someModifier',
+    };
+    const orderItem = { price: 30, quantity: 1 };
+    const computedModifier = pricingService.modifier.calculate(
+      modifier,
+      orderItem
+    );
+    const testCompute = getComputeModField(computedModifier);
+    expect(testCompute).toMatchObject({
+      type: '',
+      amount: 0,
+      action: '',
+    });
+  });
 });

package/__TEST__/modifier/createIndirectModifier.test.js

@@ -0,0 +1,166 @@
+const _ = require('lodash');
+const utils = require('@darkpos/utils');
+const createIndirectModifierFunction = require('../../lib/modifier/createIndirectModifier');
+
+describe('createIndirectModifier Function', () => {
+  test('create indirect modifier with an undefined modifier compute', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+    // const getComputeModField = jest.fn().mockReturnValue(null);
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        amount: 0,
+        action: 'subtract',
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+  test('create indirect modifier with a null modifier compute', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+      compute: null,
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        amount: 0,
+        action: 'subtract',
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+  test('create indirect modifier regular modifier', () => {
+    const constants = {
+      Modifier: {
+        Compute: {
+          Types: {
+            PERCENTAGE: 'percentage',
+            FIXED: 'fixed',
+          },
+          Actions: {
+            SUBTRACT: 'subtract',
+          },
+        },
+      },
+    };
+    const actions = {
+      getProperty: (modifier, prop) => modifier[prop],
+      create: modifier => modifier,
+    };
+
+    const createIndirectModifier = createIndirectModifierFunction({
+      _,
+      utils,
+      constants,
+      actions,
+    });
+
+    const modifier = {
+      type: 'credit',
+      properties: {},
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 10,
+      },
+    };
+    const options = {
+      orderTotal: 100,
+      itemQuantity: 2,
+      itemTotal: 50,
+    };
+
+    const result = createIndirectModifier(modifier, options);
+
+    expect(result).toEqual({
+      ...modifier,
+      direct: false,
+      compute: {
+        type: 'fixed',
+        action: 'add',
+        amount: 2.5,
+      },
+      properties: {
+        ignoreQuantity: false,
+      },
+    });
+  });
+});

package/__TEST__/modifier/getFixedModifiersTotal.test.js

@@ -0,0 +1,52 @@
+const utils = require('@darkpos/utils');
+const getFixedModifiersTotalFunction = require('../../lib/modifier/getFixedModifiersTotal');
+
+describe('getFixedModifiersTotal Function', () => {
+  const getComputeModField = jest.fn();
+
+  const getFixedModifiersTotal = getFixedModifiersTotalFunction({
+    utils,
+  });
+
+  test('should return 0 if modifiers is not an array', () => {
+    const result = getFixedModifiersTotal(null);
+    expect(result).toBe(0);
+  });
+
+  test('should return 0 if there are no fixed modifiers', () => {
+    getComputeModField.mockReturnValueOnce({ type: 'percentage' });
+    const modifiers = [{}, {}];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(0);
+  });
+
+  test('should correctly sum fixed modifiers even with a compute null', () => {
+    const modifiers = [
+      {
+        compute: { type: 'fixed', amount: 10 },
+      },
+      { compute: { type: 'fixed', amount: 20 } },
+      { compute: { type: 'fixed', amount: 30 } },
+      { compute: null },
+    ];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(60);
+  });
+
+  test('should correctly handle a fixed modifier with no amount', () => {
+    const modifiers = [
+      { compute: { type: 'fixed', amount: undefined } },
+      { compute: { type: 'fixed', amount: 15 } },
+    ];
+
+    const result = getFixedModifiersTotal(modifiers);
+    expect(result).toBe(15);
+  });
+
+  test('should correctly handle an empty array of modifiers', () => {
+    const result = getFixedModifiersTotal([]);
+    expect(result).toBe(0);
+  });
+});

package/__TEST__/modifier/getSplittedModifiers.test.js

@@ -0,0 +1,134 @@
+const utils = require('@darkpos/utils');
+const getSplittedModifiersFunction = require('../../lib/modifier/getSplittedModifiers');
+
+describe('getSplittedModifiers Function', () => {
+  const getSplittedModifiers = getSplittedModifiersFunction({
+    utils,
+  });
+
+  test('should return split credit modifier with divided maxAmount', () => {
+    const modifiers = [
+      {
+        type: 'credit',
+        properties: { maxAmount: 100 },
+      },
+    ];
+    const totalOriginOrder = 200;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        type: 'credit',
+        properties: { maxAmount: 25 }, // 100 * (50 / 200)
+        compute: {
+          type: '',
+          amount: 0,
+          action: '',
+        },
+      },
+    ]);
+  });
+
+  test('should return split fixed modifier with divided amount', () => {
+    const modifiers = [
+      {
+        compute: { amount: 80, type: 'fixed' },
+      },
+    ];
+    const totalOriginOrder = 160;
+    const totalSplitedOrder = 40;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        compute: { amount: 20, type: 'fixed' }, // 80 * (40 / 160)
+      },
+    ]);
+  });
+
+  test('should return unmodified modifier if type is not credit or fixed', () => {
+    const modifiers = [
+      {
+        type: 'non-fixed',
+        compute: { amount: 10 },
+      },
+    ];
+    const totalOriginOrder = 200;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual(modifiers); // should be unchanged
+  });
+
+  test('should return 0 maxAmount if totalOriginOrder is 0 for credit modifier', () => {
+    const modifiers = [
+      {
+        type: 'credit',
+        properties: { maxAmount: 100 },
+      },
+    ];
+    const totalOriginOrder = 0;
+    const totalSplitedOrder = 50;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        type: 'credit',
+        properties: { maxAmount: 0 },
+        compute: {
+          action: '',
+          type: '',
+          amount: 0,
+        },
+      },
+    ]);
+  });
+
+  test('should return 0 amount if totalOriginOrder is 0 for fixed modifier', () => {
+    const modifiers = [
+      {
+        compute: { amount: 80, type: 'fixed' },
+      },
+    ];
+    const totalOriginOrder = 0;
+    const totalSplitedOrder = 40;
+
+    const result = getSplittedModifiers(
+      modifiers,
+      totalOriginOrder,
+      totalSplitedOrder
+    );
+
+    expect(result).toEqual([
+      {
+        compute: { amount: 0, type: 'fixed' }, // totalOriginOrder is 0, so amount should be 0
+      },
+    ]);
+  });
+
+  test('should handle empty modifiers array', () => {
+    const result = getSplittedModifiers([], 200, 50);
+    expect(result).toEqual([]); // empty input should return empty output
+  });
+});

package/__TEST__/modifier/isComputedOverride.test.js

@@ -0,0 +1,38 @@
+const isComputedOverrideFunction = require('../../lib/modifier/isComputedOverride');
+
+describe('isComputedOverride Function', () => {
+  const Modifier = {
+    Attributes: {
+      OVERRIDE: 'override',
+    },
+  };
+
+  const isComputedOverride = isComputedOverrideFunction({
+    constants: { Modifier },
+  });
+
+  test('should return false if modifier is null or undefined', () => {
+    expect(isComputedOverride(null)).toBe(false);
+    expect(isComputedOverride(undefined)).toBe(false);
+  });
+
+  test('should return false if modifier does not have compute property', () => {
+    const modifier = {};
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return false if compute does not have action property', () => {
+    const modifier = { compute: {} };
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return false if compute action is not OVERRIDE', () => {
+    const modifier = { compute: { action: 'other_action' } };
+    expect(isComputedOverride(modifier)).toBe(false);
+  });
+
+  test('should return true if compute action is OVERRIDE', () => {
+    const modifier = { compute: { action: 'override' } };
+    expect(isComputedOverride(modifier)).toBe(true);
+  });
+});

package/__TEST__/order/addItem.test.js

@@ -10,7 +10,7 @@ const pricingService = usePricing(session);
 
 describe('addItem function', () => {
   test('should add a new item to an empty order', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock an empty order
     const order = {
@@ -44,7 +44,7 @@ describe('addItem function', () => {
   });
 
   test('should combine with an existing item if aggregation is enabled', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -83,7 +83,7 @@ describe('addItem function', () => {
   });
 
   test('should add item with overridden quantity', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -99,7 +99,7 @@ describe('addItem function', () => {
     };
 
     // Call the function with an overridden quantity
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const [updatedOrder, , addedItem] = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
@@ -114,7 +114,7 @@ describe('addItem function', () => {
   });
 
   test('should handle adding an item with modifiers', () => {
-    const addItem = pricingService.order.addItem;
+    const { addItem } = pricingService.order;
 
     // Mock order with one existing item
     const order = {
@@ -128,70 +128,74 @@ describe('addItem function', () => {
       price: 150,
       modifiers: [
         {
-            "_id": "66cdf18a1e48455e128a4f63",
-            "modifierId": 'mod1',
-            "_parentId": null,
-            "name": null,
-            "sku": null,
-            "description": null,
-            "group": null,
-            "type": null,
-            "attributes": [],
-            "color": null,
-            "backgroundColor": null,
-            "icon": null,
-            "url": null,
-            "tags": [],
-            "order": null,
-            "included": false,
-            "direct": true,
-            "hidden": false,
-            "required": false,
-            "code": null,
-            "properties": null,
-            "_computed": null
+          _id: '66cdf18a1e48455e128a4f63',
+          modifierId: 'mod1',
+          _parentId: null,
+          name: null,
+          sku: null,
+          description: null,
+          group: null,
+          type: null,
+          attributes: [],
+          color: null,
+          backgroundColor: null,
+          icon: null,
+          url: null,
+          tags: [],
+          order: null,
+          included: false,
+          direct: true,
+          hidden: false,
+          required: false,
+          code: null,
+          properties: null,
+          _computed: null,
         },
         {
-            "_id": "66cdf18a1e48455e128a4f64",
-            "modifierId": 'mod2',
-            "_parentId": null,
-            "name": null,
-            "sku": null,
-            "description": null,
-            "group": null,
-            "type": null,
-            "attributes": [],
-            "color": null,
-            "backgroundColor": null,
-            "icon": null,
-            "url": null,
-            "tags": [],
-            "order": null,
-            "included": false,
-            "direct": true,
-            "hidden": false,
-            "required": false,
-            "code": null,
-            "properties": null,
-            "_computed": null
+          _id: '66cdf18a1e48455e128a4f64',
+          modifierId: 'mod2',
+          _parentId: null,
+          name: null,
+          sku: null,
+          description: null,
+          group: null,
+          type: null,
+          attributes: [],
+          color: null,
+          backgroundColor: null,
+          icon: null,
+          url: null,
+          tags: [],
+          order: null,
+          included: false,
+          direct: true,
+          hidden: false,
+          required: false,
+          code: null,
+          properties: null,
+          _computed: null,
         },
       ],
     };
 
     // Call the function
-    const [updatedOrder, itemIndex, addedItem] = addItem({
+    const [updatedOrder] = addItem({
       order,
       item,
       itemIndex: -1, // Assuming no explicit index
       cache: addItemObj.cache, // Assuming some cache object
       overridenQuantity: -1, // No overridden quantity
     });
-    
+
     // Assertions
     expect(updatedOrder.items).toHaveLength(1); // Should have one item
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Item should have two modifiers
-    expect(updatedOrder.items[0].modifiers[0].modifierId).toBe('66cdf18a1e48455e128a4f63'); // Check first modifier
-    expect(updatedOrder.items[0].modifiers[1].modifierId).toBe('66cdf18a1e48455e128a4f64'); // Check second modifier
+    expect(updatedOrder.items[0].modifiers[0].modifierId).toBe(
+      '66cdf18a1e48455e128a4f63'
+    ); // Check first modifier
+    expect(updatedOrder.items[0].modifiers[1].modifierId).toBe(
+      '66cdf18a1e48455e128a4f64'
+    ); // Check second modifier
     expect(updatedOrder.items[0].modifiers).toHaveLength(2); // Added item should have modifiers
   });
 });

package/__TEST__/order/adjustFixedModifiersDifference.test.js

@@ -0,0 +1,117 @@
+const adjustFixedModifiersDifferenceFunction = require('../../lib/order/adjustFixedModifiersDifference');
+
+describe('adjustFixedModifiersDifference Function', () => {
+  const math = {
+    add: jest.fn(),
+  };
+  const _ = {
+    get: jest.fn(),
+  };
+  const actions = {
+    isOpen: jest.fn(),
+    calculate: jest.fn(),
+  };
+
+  const modifierActions = {
+    hasFixedModifier: jest.fn(),
+  };
+
+  const getComputeModField = jest.fn();
+
+  const adjustFixedModifiersDifference = adjustFixedModifiersDifferenceFunction(
+    {
+      utils: { math },
+      actions,
+      modifierActions,
+      _,
+    }
+  );
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should adjust the fixed modifier for a suitable subOrder', () => {
+    const subOrders = [
+      { id: 'subOrder1', total: 100, modifiers: [] },
+      {
+        id: 'subOrder2',
+        total: 200,
+        modifiers: [{ compute: { type: 'fixed', amount: 50 } }],
+      },
+    ];
+    const difference = 20;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(true);
+    actions.isOpen.mockReturnValueOnce(true);
+    getComputeModField.mockReturnValueOnce({ compute: { amount: 50 } });
+    math.add.mockReturnValueOnce(70);
+    actions.calculate.mockReturnValueOnce({
+      id: 'subOrder2',
+      total: 200,
+      modifiers: [{ compute: { type: 'fixed', amount: 70 } }],
+    });
+    _.get.mockReturnValueOnce(50);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual([
+      { id: 'subOrder1', total: 100, modifiers: [] },
+      {
+        id: 'subOrder2',
+        total: 200,
+        modifiers: [{ compute: { type: 'fixed', amount: 70 } }],
+      },
+    ]);
+
+    expect(math.add).toHaveBeenCalledWith(50, difference);
+  });
+
+  test('should not adjust if no suitable subOrder is found', () => {
+    const subOrders = [
+      {
+        id: 'subOrder1',
+        total: 100,
+        modifiers: [{ compute: { type: 'fixed', amount: 50 } }],
+      },
+      { id: 'subOrder2', total: 50, modifiers: [] },
+    ];
+    const difference = 200;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false);
+    actions.isOpen.mockReturnValueOnce(true).mockReturnValueOnce(true);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual(subOrders);
+    expect(math.add).not.toHaveBeenCalled();
+    expect(actions.calculate).not.toHaveBeenCalled();
+  });
+
+  test('should not adjust if no suitable subOrder is found and compute is null', () => {
+    const subOrders = [
+      {
+        id: 'subOrder1',
+        total: 100,
+        modifiers: [{ compute: null }],
+      },
+      { id: 'subOrder2', total: 50, modifiers: [] },
+    ];
+    const difference = 200;
+
+    modifierActions.hasFixedModifier
+      .mockReturnValueOnce(true)
+      .mockReturnValueOnce(false);
+    actions.isOpen.mockReturnValueOnce(true).mockReturnValueOnce(true);
+
+    const result = adjustFixedModifiersDifference({ subOrders, difference });
+
+    expect(result).toEqual(subOrders);
+    expect(math.add).not.toHaveBeenCalled();
+    expect(actions.calculate).not.toHaveBeenCalled();
+  });
+});

package/__TEST__/order/order.test.js

@@ -2240,4 +2240,51 @@ describe('Order actions', () => {
 
     expect(newOrderFixedModifier).toHaveProperty('total', 120);
   });
+
+  test('Get calculated Order, multiple items and indirect modifiers and null compute', () => {
+    const item1 = {
+      _id: 1,
+      price: 30,
+      quantity: 2,
+    };
+    const item2 = {
+      _id: 2,
+      price: 10,
+      quantity: 1,
+    };
+    const modifier1 = {
+      compute: null,
+      name: 'modifier1',
+      type: 'discount',
+    };
+
+    const order = { items: [item1, item2], modifiers: [modifier1] };
+
+    const newOrder = pricingService.order.calculate(order);
+    expect(newOrder).toHaveProperty('total', 70);
+    expect(newOrder).toHaveProperty('subTotal', 70);
+    expect(newOrder).toHaveProperty('subTotals', {
+      discount: 0,
+    });
+    expect(newOrder.items[0]).toHaveProperty('total', 60);
+    expect(newOrder.items[0]).toHaveProperty('subTotals', {
+      discount: 0,
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 60,
+      _actual: 60,
+    });
+    expect(newOrder.items[1]).toHaveProperty('total', 10);
+    expect(newOrder.items[1]).toHaveProperty('subTotals', {
+      discount: 0,
+      _included: 0,
+      _xincluded: 0,
+      _direct: 0,
+      _xdirect: 0,
+      _simple: 10,
+      _actual: 10,
+    });
+  });
 });

package/lib/item/addIndirectModifier.js

@@ -1,4 +1,5 @@
-module.exports = ({ utils, modifierActions }) => {
+module.exports = ({ utils, modifierActions, _ }) => {
+  const { getComputeModField } = require('../modifier/utils');
   const { math } = utils;
 
   return function addIndirectModifier({ orderTotal, items, modifier }) {
@@ -25,7 +26,9 @@ module.exports = ({ utils, modifierActions }) => {
       );
     }, 0);
 
-    if (modifier.compute.type === 'percentage' && modifier.type !== 'credit')
+    const modifierType = _.get(modifier, 'modifier.type', '');
+    const computeField = getComputeModField(modifier);
+    if (computeField.type === 'percentage' && modifierType !== 'credit')
       return itemsModifiers;
 
     if (math.abs(totalDistributed) !== math.abs(orderModifierTotal)) {

package/lib/item/calculate.js

@@ -2,6 +2,8 @@
 module.exports = ({ _, utils, actions, modifierActions }) => {
   const { math } = utils;
   //
+  const { getComputeModField } = require('../modifier/utils');
+
   const calculateOne = inputItem => {
     const item = _.cloneDeep(inputItem);
     if (!item) return item;
@@ -70,8 +72,10 @@ module.exports = ({ _, utils, actions, modifierActions }) => {
         const computedAmountCalc = math.mul(_computed.amount, quantity);
         const computedPriceCalc = math.mul(computedPrice * quantity);
 
+        // adding this computeField because now the compute from a modifier can be null
+        const computeField = getComputeModField(_modifier);
         let computedAmount =
-          _modifier.compute.type === 'percentage' ||
+          computeField.type === 'percentage' ||
           modifierActions.isIgnoreQuantity(_modifier) ||
           (!modifierActions.isFixedAdd(_modifier) &&
             math.gt(math.abs(computedAmountCalc), computedPriceCalc))

package/lib/modifier/calculate.js

@@ -1,3 +1,5 @@
+const { getComputeModField } = require('./utils');
+
 /**
  * Get calculated modifier
  */
@@ -9,8 +11,9 @@ module.exports = ({ _, constants, utils, localization, actions }) => {
     modifier = {},
     options = { price: 0, quantity: 0, skip: false }
   ) {
-    const { name, compute } = modifier;
-    const { type, action, amount = 0 } = compute || {};
+    const { name } = modifier;
+    const compute = getComputeModField(modifier);
+    const { type, action, amount = 0 } = compute;
     const _computed = {
       amount: 0,
       description: '',

package/lib/modifier/createIndirectModifier.js

@@ -4,15 +4,16 @@
 module.exports = ({ _, utils, constants, actions }) => {
   const { math } = utils;
   const { Modifier } = constants;
-
+  const { getComputeModField } = require('./utils');
   return function createIndirectModifier(
     modifier,
     options = { orderTotal: 0, itemQuantity: 1, itemTotal: 0 }
   ) {
     const maxAmount = actions.getProperty(modifier, 'maxAmount');
 
-    const compute = modifier.compute || {};
-    const { type, amount = 0 } = compute;
+    const compute = getComputeModField(modifier);
+    const type = _.get(compute, 'type', '');
+    const amount = _.get(compute, 'amount', 0);
     let modifierAmount = amount;
 
     if (type === Modifier.Compute.Types.PERCENTAGE) {

package/lib/modifier/getFixedModifiersTotal.js

@@ -1,12 +1,13 @@
 module.exports = ({ utils }) => {
   const { math } = utils;
-
+  const { getComputeModField } = require('./utils');
   return function getFixedModifiersTotal(modifiers) {
     if (!Array.isArray(modifiers)) return 0;
 
-    const fixedModifiers = modifiers.filter(
-      mod => mod.compute.type === 'fixed'
-    );
+    const fixedModifiers = modifiers.filter(mod => {
+      const compute = getComputeModField(mod);
+      return compute.type === 'fixed';
+    });
 
     return fixedModifiers.reduce(
       (acc, modifier) => math.add(acc, modifier.compute.amount || 0),

package/lib/modifier/getSplittedModifiers.js

@@ -1,5 +1,6 @@
 module.exports = ({ utils }) => {
   const { math } = utils;
+  const { getComputeModField } = require('./utils');
 
   const divideModifierAmount = ({
     totalOriginOrder,
@@ -25,10 +26,11 @@ module.exports = ({ utils }) => {
       totalOriginOrder,
       totalSplitedOrder,
     });
+    const compute = getComputeModField(modifier);
     return {
       ...modifier,
       compute: {
-        ...modifier.compute,
+        ...compute,
       },
       properties: {
         ...modifier.properties,
@@ -63,7 +65,7 @@ module.exports = ({ utils }) => {
   ) {
     return modifiers.map(each => {
       const modifier = { ...each };
-
+      const compute = getComputeModField(modifier);
       if (modifier.type === 'credit') {
         return splitCreditModifier({
           modifier,
@@ -72,11 +74,7 @@ module.exports = ({ utils }) => {
         });
       }
 
-      if (
-        modifier.compute &&
-        modifier.compute.type === 'fixed' &&
-        modifier.compute.amount
-      ) {
+      if (compute && compute.type === 'fixed' && compute.amount) {
         return splitFixedModifier({
           modifier,
           totalOriginOrder,

package/lib/modifier/isComputedOverride.js

@@ -1,7 +1,8 @@
-module.exports = ({ actions, constants }) => {
+module.exports = ({ constants }) => {
   const { Modifier } = constants;
   return function isComputedOverride(modifier) {
-    const computeAction = modifier && modifier.compute && modifier.compute.action;
+    const computeAction =
+      modifier && modifier.compute && modifier.compute.action;
     return computeAction === Modifier.Attributes.OVERRIDE;
   };
 };

package/lib/modifier/utils.js

@@ -0,0 +1,10 @@
+const _ = require('lodash');
+
+const getComputeModField = modifier =>
+  _.isNull(modifier.compute) || !modifier.compute
+    ? { type: '', amount: 0, action: '' }
+    : modifier.compute;
+
+module.exports = {
+  getComputeModField,
+};

package/lib/order/addItemModifier.js

@@ -1,9 +1,10 @@
 module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
   const { math } = utils;
+  const { getComputeModField } = require('../modifier/utils');
 
   const getPrice = ({ item, modifier }) => {
-    const amount =
-      (modifier && modifier.compute && modifier.compute.amount) || 0;
+    const compute = getComputeModField(modifier);
+    const amount = (modifier && compute && compute.amount) || 0;
     const { price = 0 } = item;
     if (modifierActions.isMultiplier(modifier)) return math.mul(price, amount);
     return amount;
@@ -64,6 +65,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     },
   }) => {
     let item = { ...itemProp };
+    const compute = getComputeModField(modifier);
     if (hasBehaivoralFields(modifier)) return item;
     // check conditions
     if (!areConditionsMet(item, modifier.conditions)) return item;
@@ -91,7 +93,7 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
     if (modifierActions.isAmountOverride(modifier)) {
       item = {
         ...item,
-        price: modifier.compute.amount,
+        price: compute.amount,
       };
     }
 
@@ -99,7 +101,10 @@ module.exports = ({ actions, itemActions, modifierActions, utils, _ }) => {
       item.quantity = modifier.compute.amount || 1;
     }
 
-    if (modifierActions.isPriceOverride(modifier) ||  modifierActions.isComputedOverride(modifier)) {
+    if (
+      modifierActions.isPriceOverride(modifier) ||
+      modifierActions.isComputedOverride(modifier)
+    ) {
       item.price = getPrice({ modifier, item });
     } else {
       item.price = itemActions.getItemPrice({

package/lib/order/addModifier.js

@@ -1,11 +1,12 @@
-module.exports = ({ actions, modifierActions }) =>
-  function addModifier({ order, modifier }) {
+module.exports = ({ actions, modifierActions }) => {
+  const { getComputeModField } = require('../modifier/utils');
+  return function addModifier({ order, modifier }) {
     if (!modifier) return order;
     const { modifiers = [] } = order;
-
     if (modifierActions.isFixedDiscount(modifier)) {
+      const compute = getComputeModField(modifier);
       const orderDue = actions.calculateDue(order);
-      if (modifier.compute.amount > orderDue) {
+      if (compute.amount > orderDue) {
         const err = new Error();
         err.valid = false;
         err.orderDue = orderDue;
@@ -19,3 +20,4 @@ module.exports = ({ actions, modifierActions }) =>
       modifiers: [...modifiers, { ...modifier }],
     };
   };
+};

package/lib/order/adjustFixedModifiersDifference.js

@@ -1,6 +1,6 @@
-module.exports = ({ utils, actions, modifierActions }) => {
+module.exports = ({ utils, actions, modifierActions, _ }) => {
   const { math } = utils;
-
+  const { getComputeModField } = require('../modifier/utils');
   return function adjustFixedModifiersDifference({ subOrders, difference }) {
     const selectedSubOrderIndex = subOrders.findIndex(
       subOrder =>
@@ -15,15 +15,16 @@ module.exports = ({ utils, actions, modifierActions }) => {
       };
 
       const modifierToUpdateIdx = subOrderToUpdate.modifiers.findIndex(
-        mod => mod.compute.type === 'fixed'
+        mod => mod.compute && mod.compute.type === 'fixed'
       );
-      const prevAmount =
-        subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount;
-
-      subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount = math.add(
-        prevAmount,
-        difference
+      const prevCompute = getComputeModField(
+        subOrderToUpdate.modifiers[modifierToUpdateIdx]
       );
+      const prevAmount = _.get(prevCompute, 'compute.amount', 0);
+      if (modifierToUpdateIdx !== -1) {
+        subOrderToUpdate.modifiers[modifierToUpdateIdx].compute.amount =
+          math.add(prevAmount, difference);
+      }
       subOrders.splice(
         selectedSubOrderIndex,
         1,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@darkpos/pricing",
-  "version": "1.0.31",
+  "version": "1.0.32",
   "description": "Pricing calculator",
   "author": "Dark POS",
   "license": "ISC",
@@ -36,5 +36,5 @@
     "supertest": "^6.2.3",
     "supervisor": "^0.12.0"
   },
-  "gitHead": "a864feac96c47884de2da753f60ea69856bcb914"
+  "gitHead": "5c5b8c5f55437733d8f9d8f9bbba00d27a6f7c59"
 }