@darkpos/pricing 1.0.41 → 1.0.44

package/__TEST__/mocks/unpaid/order-modifiers.json

@@ -1,53 +1,49 @@
 [
-    {
-        "__typename": "Modifier",
-        "addModifiers": [],
-        "delModifiers": [],
-        "conditions": {
-            "__typename": "Conditions",
-            "paymentTypes": [
-                "cash"
-            ],
-            "paymentMethods": [],
-            "modifiers": [],
-            "minItemQuantity": 0,
-            "minItemPieces": 0
-        },
-        "compute": {
-            "__typename": "Compute",
-            "type": "fixed",
-            "action": "add",
-            "amount": 2
-        },
-        "_createdAt": "2022-11-08T16:09:49.227Z",
-        "_updatedAt": "2022-11-28T18:44:16.821Z",
-        "_id": "636a7f3ec19c040636f3da9a",
-        "modifierId": null,
-        "_parentId": null,
-        "locked": false,
-        "name": "Cash fee",
-        "sku": "",
-        "description": "",
-        "group": "",
-        "type": "fee",
-        "attributes": [],
-        "color": "",
-        "backgroundColor": "",
-        "icon": "",
-        "url": "",
-        "tags": [
-            "default"
-        ],
-        "order": 0,
-        "included": false,
-        "direct": true,
-        "hidden": false,
-        "print": true,
-        "required": false,
-        "recommended": false,
-        "default": false,
-        "code": "",
-        "properties": null,
-        "_computed": null
-    }
-]
+  {
+    "__typename": "Modifier",
+    "addModifiers": [],
+    "delModifiers": [],
+    "conditions": {
+      "rules": [ {
+        "key": "paymentTypes",
+        "operand": "$in",
+        "value": ["cash"]
+      }
+    ]
+    },
+    "compute": {
+      "__typename": "Compute",
+      "type": "fixed",
+      "action": "add",
+      "amount": 2
+    },
+    "_createdAt": "2022-11-08T16:09:49.227Z",
+    "_updatedAt": "2022-11-28T18:44:16.821Z",
+    "_id": "636a7f3ec19c040636f3da9a",
+    "modifierId": null,
+    "_parentId": null,
+    "locked": false,
+    "name": "Cash fee",
+    "sku": "",
+    "description": "",
+    "group": "",
+    "type": "fee",
+    "attributes": [],
+    "color": "",
+    "backgroundColor": "",
+    "icon": "",
+    "url": "",
+    "tags": ["default"],
+    "order": 0,
+    "included": false,
+    "direct": true,
+    "hidden": false,
+    "print": true,
+    "required": false,
+    "recommended": false,
+    "default": false,
+    "code": "",
+    "properties": null,
+    "_computed": null
+  }
+]

package/__TEST__/modifier/calculate.test.js

@@ -1,6 +1,7 @@
 const usePricing = require('../../index');
 
 const { getComputeModField } = require('../../lib/modifier/utils');
+
 const pricingService = usePricing();
 
 describe('Calculate Function', () => {

package/__TEST__/modifier/getGroupedModifierLabels.test.js

@@ -0,0 +1,95 @@
+const getGroupedModifierLabelsFunction = require('../../lib/modifier/getGroupedModifierLabels');
+
+describe('getGroupedModifierLabels Function', () => {
+  const actions = {
+    getGroupedModifiers: jest.fn(),
+  };
+
+  const getGroupedModifierLabels = getGroupedModifierLabelsFunction({
+    actions,
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test('should return an empty array if no modifiers are provided', () => {
+    actions.getGroupedModifiers.mockReturnValueOnce([]);
+
+    const result = getGroupedModifierLabels([]);
+
+    expect(result).toEqual([]);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([]);
+  });
+
+  test('should map modifiers to labels and group them by modifierId', () => {
+    const modifiers = [
+      { name: 'Modifier 1', modifierId: 'mod1' },
+      { name: 'Modifier 2', modifierId: 'mod2' },
+    ];
+
+    const groupedModifiers = [
+      { label: '1 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: '1 Modifier 2', value: 'mod2', data: modifiers[1], quantity: 1 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['1 Modifier 1', '1 Modifier 2']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: 'Modifier 2', value: 'mod2', data: modifiers[1], quantity: 1 },
+    ]);
+  });
+
+  test('should group modifiers with the same modifierId and increment quantity', () => {
+    const modifiers = [
+      { name: 'Modifier 1', modifierId: 'mod1' },
+      { name: 'Modifier 1', modifierId: 'mod1' }, // Same modifierId
+    ];
+
+    const groupedModifiers = [
+      { label: '2 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 2 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['2 Modifier 1']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[1], quantity: 1 },
+    ]);
+  });
+
+  test('should handle a single modifier correctly', () => {
+    const modifiers = [{ name: 'Modifier 1', modifierId: 'mod1' }];
+
+    const groupedModifiers = [
+      { label: '1 Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+    ];
+
+    actions.getGroupedModifiers.mockReturnValueOnce(groupedModifiers);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual(['1 Modifier 1']);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([
+      { label: 'Modifier 1', value: 'mod1', data: modifiers[0], quantity: 1 },
+    ]);
+  });
+
+  test('should correctly handle an empty modifiers array', () => {
+    const modifiers = [];
+
+    actions.getGroupedModifiers.mockReturnValueOnce([]);
+
+    const result = getGroupedModifierLabels(modifiers);
+
+    expect(result).toEqual([]);
+    expect(actions.getGroupedModifiers).toHaveBeenCalledWith([]);
+  });
+});

package/__TEST__/modifier/getGroupedModifiers.test.js

@@ -0,0 +1,65 @@
+const getGroupedModifiersFunction = require('../../lib/modifier/getGroupedModifiers');
+
+describe('getGroupedModifiers Function', () => {
+  const getGroupedModifiers = getGroupedModifiersFunction();
+
+  test('should return an empty array if no tags are provided', () => {
+    const result = getGroupedModifiers([]);
+    expect(result).toEqual([]);
+  });
+
+  test('should group modifiers by modifierId and increment quantity', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '2 Modifier 1', data: { modifierId: 'mod1' }, quantity: 2 },
+      { label: '1 Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should correctly handle tags with different modifierIds', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '1 Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: '1 Modifier 2', data: { modifierId: 'mod2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should not modify original tags array', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const originalTagsCopy = [...tags];
+
+    getGroupedModifiers(tags);
+
+    expect(tags).toEqual(originalTagsCopy); // Ensure original array is not mutated
+  });
+
+  test('should format the label to include the quantity', () => {
+    const tags = [
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+      { label: 'Modifier 1', data: { modifierId: 'mod1' }, quantity: 1 },
+    ];
+
+    const result = getGroupedModifiers(tags);
+
+    expect(result).toEqual([
+      { label: '2 Modifier 1', data: { modifierId: 'mod1' }, quantity: 2 },
+    ]);
+  });
+});

package/__TEST__/modifier/getMatchTagsModifiers.test.js

@@ -10,45 +10,75 @@ describe('GetMatchTagsModifiers Function', () => {
     const customer = {};
     let modifiers = [];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     customer.tags = [];
     modifiers = [{ tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     customer.tags = ['all'];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     customer.tags = ['test'];
     modifiers = [{ tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }, { tags: [] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -57,7 +87,10 @@ describe('GetMatchTagsModifiers Function', () => {
       { tags: ['Test'] },
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -67,15 +100,24 @@ describe('GetMatchTagsModifiers Function', () => {
       { tags: ['test', 'Test'] },
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     modifiers = [{ tags: ['all'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(0);
     modifiers = [{ tags: ['all'] }, { tags: ['test'] }];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(1);
     modifiers = [
       { tags: ['all'] },
@@ -84,11 +126,17 @@ describe('GetMatchTagsModifiers Function', () => {
       {},
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     customer.tags = ['all'];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(2);
     modifiers = [
       { tags: ['all'] },
@@ -99,11 +147,17 @@ describe('GetMatchTagsModifiers Function', () => {
       {},
     ];
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(5);
     customer.tags = undefined;
     expect(
-      pricingService.modifier.getMatchTagsModifiers({ modifiers, entity: customer })
+      pricingService.modifier.getMatchTagsModifiers({
+        modifiers,
+        entity: customer,
+      })
     ).toHaveLength(5);
   });
 });

package/__TEST__/modifier/getModifierIndex.test.js

@@ -12,7 +12,10 @@ describe('GetModifierIndex Function', () => {
     ).toBe(-1);
     const order = { modifiers: [{ modifierId: '123' }] };
     expect(
-      pricingService.modifier.getModifierIndex({ entity: order, modifier: undefined })
+      pricingService.modifier.getModifierIndex({
+        entity: order,
+        modifier: undefined,
+      })
     ).toBe(-1);
     const modifier = { _id: '123' };
     expect(
@@ -29,12 +32,12 @@ describe('GetModifierIndex Function', () => {
       })
     ).toBe(-1);
     order.modifiers = [{ modifierId: '123' }, { modifierId: '234' }];
-    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
-      1
-    );
+    expect(
+      pricingService.modifier.getModifierIndex({ entity: order, modifier })
+    ).toBe(1);
     modifier._id = '123';
-    expect(pricingService.modifier.getModifierIndex({ entity: order, modifier })).toBe(
-      0
-    );
+    expect(
+      pricingService.modifier.getModifierIndex({ entity: order, modifier })
+    ).toBe(0);
   });
 });

package/__TEST__/modifier/getNotesToModifierTags.test.js

@@ -0,0 +1,78 @@
+const getNotesToModifierTagsFunction = require('../../lib/modifier/getNotesToModifierTags');
+
+describe('getNotesToModifierTags Function', () => {
+  const getNotesToModifierTags = getNotesToModifierTagsFunction();
+
+  test('should return modifierTags if no notes are provided', () => {
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes: null, modifierTags });
+    expect(result).toEqual(modifierTags);
+  });
+
+  test('should return modifierTags if notes array is empty', () => {
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes: [], modifierTags });
+    expect(result).toEqual(modifierTags);
+  });
+
+  test('should filter out notes that are null or have a url', () => {
+    const notes = [
+      { message: 'Note 1' },
+      { message: 'Note 2', url: 'http://example.com' }, // Should be filtered out
+      null, // Should be filtered out
+    ];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      { label: 'Note 1', value: '0', data: { message: 'Note 1' }, quantity: 1 },
+    ]);
+  });
+
+  test('should map notes to noteTags and append to modifierTags', () => {
+    const notes = [{ message: 'Note 1' }, { message: 'Note 2' }];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      { label: 'Note 1', value: '0', data: { message: 'Note 1' }, quantity: 1 },
+      { label: 'Note 2', value: '1', data: { message: 'Note 2' }, quantity: 1 },
+    ]);
+  });
+
+  test('should handle case where notes contain falsy values', () => {
+    const notes = [null, undefined, { message: 'Valid Note' }];
+
+    const modifierTags = [
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+    ];
+
+    const result = getNotesToModifierTags({ notes, modifierTags });
+
+    expect(result).toEqual([
+      { label: 'Modifier 1', value: 'mod1', data: {}, quantity: 1 },
+      {
+        label: 'Valid Note',
+        value: '0',
+        data: { message: 'Valid Note' },
+        quantity: 1,
+      },
+    ]);
+  });
+});

package/__TEST__/modifier/getRecommendedModifiers.test.js

@@ -5,13 +5,15 @@ const pricingService = usePricing();
 describe('GetRecommendedModifiers Function', () => {
   test('usecases', () => {
     const modifier = { modifier: { recommended: true } };
-    expect(pricingService.modifier.getRecommendedModifiers([modifier])).toHaveLength(1);
+    expect(
+      pricingService.modifier.getRecommendedModifiers([modifier])
+    ).toHaveLength(1);
 
     const modifier2 = {
       modifier: { modifier: { _id: 1 } },
     };
-    expect(pricingService.modifier.getRecommendedModifiers([modifier2])).toHaveLength(
-      0
-    );
+    expect(
+      pricingService.modifier.getRecommendedModifiers([modifier2])
+    ).toHaveLength(0);
   });
 });

package/__TEST__/modifier/hasAttribute.test.js

@@ -7,17 +7,23 @@ describe('Has Modifiers Function', () => {
     expect(pricingService.modifier.hasAttribute()).toBe(false);
     expect(pricingService.modifier.hasAttribute(undefined, 'test')).toBe(false);
     expect(pricingService.modifier.hasAttribute({}, undefined)).toBe(false);
-    expect(pricingService.modifier.hasAttribute({ attributes: [] }, undefined)).toBe(
-      false
-    );
     expect(
-      pricingService.modifier.hasAttribute({ attributes: [undefined] }, undefined)
+      pricingService.modifier.hasAttribute({ attributes: [] }, undefined)
+    ).toBe(false);
+    expect(
+      pricingService.modifier.hasAttribute(
+        { attributes: [undefined] },
+        undefined
+      )
     ).toBe(false);
     expect(
       pricingService.modifier.hasAttribute({ attributes: ['test'] }, undefined)
     ).toBe(false);
     expect(
-      pricingService.modifier.hasAttribute({ attributes: ['undefined'] }, undefined)
+      pricingService.modifier.hasAttribute(
+        { attributes: ['undefined'] },
+        undefined
+      )
     ).toBe(false);
     expect(
       pricingService.modifier.hasAttribute(