@merchi/sdk 1.40.2

package/src/pricing/discount.test.ts

@@ -0,0 +1,47 @@
+import { applyDiscount } from './discount.js';
+import { DiscountGroup } from './types.js';
+
+const group: DiscountGroup = {
+  groupRestricted: false,
+  discounts: [
+    { lowerLimit: 100, amount: 5 },
+    { lowerLimit: 500, amount: 12 },
+  ],
+};
+
+test('no group returns price unchanged (rounded)', () => {
+  expect(applyDiscount(10, 50, null)).toBe(10);
+});
+
+test('below lowest tier: no discount', () => {
+  expect(applyDiscount(10, 50, group)).toBe(10);
+});
+
+test('picks highest tier whose lowerLimit <= qty', () => {
+  expect(applyDiscount(10, 100, group)).toBe(9.5);
+  expect(applyDiscount(10, 499, group)).toBe(9.5);
+  expect(applyDiscount(10, 500, group)).toBe(8.8);
+});
+
+test('empty discounts: no discount', () => {
+  expect(applyDiscount(10, 1000, { groupRestricted: false, discounts: [] })).toBe(10);
+});
+
+test('explicit zero-amount tier is applied (distinct from below-tier)', () => {
+  expect(
+    applyDiscount(10, 100, {
+      groupRestricted: false,
+      discounts: [{ lowerLimit: 100, amount: 0 }],
+    })
+  ).toBe(10);
+});
+
+test('applied discount is rounded to 3dp', () => {
+  // 10 * (1 - 33.333/100) = 6.6667 -> 3dp -> 6.667
+  expect(
+    applyDiscount(10, 100, {
+      groupRestricted: false,
+      discounts: [{ lowerLimit: 100, amount: 33.333 }],
+    })
+  ).toBe(6.667);
+});

package/src/pricing/discount.ts

@@ -0,0 +1,17 @@
+import { DiscountGroup } from './types.js';
+import { roundHalfEven } from './round.js';
+
+export function applyDiscount(
+  price: number,
+  qty: number,
+  group: DiscountGroup | null
+): number {
+  if (!group || group.discounts.length === 0) {
+    return roundHalfEven(price, 3);
+  }
+  const applicable = group.discounts
+    .filter((d) => d.lowerLimit <= qty)
+    .sort((a, b) => b.lowerLimit - a.lowerLimit);
+  const amount = applicable.length ? applicable[0].amount : 0;
+  return roundHalfEven(price * (1 - amount / 100), 3);
+}

package/src/pricing/estimate.test.ts

@@ -0,0 +1,486 @@
+import { estimateQuote } from './estimate.js';
+import { PricingRules, QuoteResult } from './types.js';
+
+const base: PricingRules = {
+  currency: 'AUD', taxPercent: 10,
+  product: { unitPrice: 10, minimumPrice: null, discountGroup: null },
+  fields: [], groupFields: [], hasGroups: false,
+};
+
+test('returns unsupported when rules flag it', () => {
+  const r = estimateQuote({ ...base, unsupported: 'group_buy_product' }, { quantity: 5, fieldValues: {} });
+  expect(r).toEqual({ unsupported: 'group_buy_product' });
+});
+
+test('simple linear price + tax', () => {
+  const r = estimateQuote(base, { quantity: 5, fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(50);
+  expect(r.taxAmount).toBe(5);
+  expect(r.totalCost).toBe(55);
+  expect(r.costPerUnit).toBe(10);
+  expect(r.currency).toBe('AUD');
+});
+
+test('minimum price floor raises unit price', () => {
+  const rules = { ...base, product: { unitPrice: 10, minimumPrice: 80, discountGroup: null } };
+  const r = estimateQuote(rules, { quantity: 5, fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(80);
+});
+
+test('quantity-break discount applied', () => {
+  const rules = {
+    ...base,
+    product: {
+      unitPrice: 10, minimumPrice: null,
+      discountGroup: { groupRestricted: false, discounts: [{ lowerLimit: 100, amount: 10 }] },
+    },
+  };
+  const r = estimateQuote(rules, { quantity: 100, fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(900);
+});
+
+test('selectable field option setup + unit cost', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [{
+      id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [{
+        id: 101, originalId: 101, position: 0, default: false,
+        variationCost: 5, variationUnitCost: 0.5,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+      }],
+    }],
+  };
+  const r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [101] } } }) as QuoteResult;
+  expect(r.cost).toBe(110); // 10*10 + 5 + 0.5*10
+});
+
+test('hidden conditional field is not costed', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [{
+      id: 2, originalId: 2, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [999],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [{
+        id: 201, originalId: 201, position: 0, default: false,
+        variationCost: 7, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+      }],
+    }],
+  };
+  const r = estimateQuote(rules, { quantity: 10, fieldValues: { 2: { selectedOptionIds: [201] } } }) as QuoteResult;
+  expect(r.cost).toBe(100);
+});
+
+test('area field multiplies height/width rate cards when dimensions set', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: { unitPrice: 1, minimumPrice: null, discountGroup: null },
+    fields: [{
+      id: 14, originalId: 14, position: 0, fieldType: 14, independent: true,
+      isSelectable: false, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      areaUnit: 'mm',
+      heightVariationCost: 2, widthVariationCost: 2,
+      heightVariationUnitCost: 3, widthVariationUnitCost: 4,
+      heightVariationCostDiscountGroup: null,
+      heightVariationUnitCostDiscountGroup: null,
+      widthVariationCostDiscountGroup: null,
+      widthVariationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+  };
+  const empty = estimateQuote(rules, {
+    quantity: 1, fieldValues: { 14: { value: '' } },
+  }) as QuoteResult;
+  expect(empty.cost).toBe(1);
+  const priced = estimateQuote(rules, {
+    quantity: 1, fieldValues: { 14: { value: '2,5' } },
+  }) as QuoteResult;
+  // area 2*5=10; onceOff 2*2*10=40; unit 3*4*10=120 → cost = 1 + 40 + 120 = 161
+  expect(priced.cost).toBe(161);
+  expect(priced.totalCost).toBe(177.1); // +10% tax
+
+  // String fieldType (some JSON paths) must still hit the area calculator.
+  const asString = estimateQuote(
+    {
+      ...rules,
+      fields: [{ ...rules.fields[0], fieldType: '14' as unknown as number }],
+    },
+    { quantity: 1, fieldValues: { 14: { value: '2,5' } } },
+  ) as QuoteResult;
+  expect(asString.cost).toBe(161);
+});
+
+test('non-selectable field with value adds field cost; empty adds nothing', () => {
+  const mk = (sel: any) => {
+    const rules: PricingRules = {
+      ...base,
+      fields: [{
+        id: 3, originalId: 3, position: 0, fieldType: 5, independent: true,
+        isSelectable: false, selectedBy: [],
+        variationCost: 4, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [],
+      }],
+    };
+    return estimateQuote(rules, { quantity: 10, fieldValues: { 3: sel } }) as QuoteResult;
+  };
+  expect(mk({ value: 'hello' }).cost).toBe(104);
+  expect(mk({ value: '' }).cost).toBe(100);
+  expect(mk(undefined as any).cost).toBe(100);
+  // Server `is_empty` uses `not self.value`: numeric 0 is empty, string '0' is not.
+  expect(mk({ value: 0 }).cost).toBe(100);
+  expect(mk({ value: '0' }).cost).toBe(104);
+});
+
+test('tax computed from unrounded cost, not rounded cost (non-10% rate)', () => {
+  const rules: PricingRules = {
+    ...base,
+    taxPercent: 33,
+    fields: [{
+      id: 7, originalId: 7, position: 0, fieldType: 5, independent: true,
+      isSelectable: false, selectedBy: [],
+      variationCost: 0.075, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+  };
+  const r = estimateQuote(rules, { quantity: 10, fieldValues: { 7: { value: 'x' } } }) as QuoteResult;
+  // unrounded cost = 100 + 0.075 = 100.075
+  expect(r.cost).toBe(100.08); // roundHalfEven(100.075, 2)
+  // tax from UNROUNDED: round(100.075*0.33, 2) = round(33.02475, 2) = 33.02
+  // (the buggy round(round(100.075,2)*0.33,2) would give 33.03)
+  expect(r.taxAmount).toBe(33.02);
+  expect(r.totalCost).toBe(133.1); // round(100.075 + 33.02475, 3)
+});
+
+test('zero-qty group adds no field cost even when a visible field has value', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    groupFields: [
+      {
+        id: 50, originalId: 50, position: 0, fieldType: 5, independent: false,
+        isSelectable: false, selectedBy: [],
+        variationCost: 20, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [],
+      },
+      {
+        // hidden conditional group field: skipped in the non-zero-qty group too
+        id: 51, originalId: 51, position: 1, fieldType: 5, independent: false,
+        isSelectable: false, selectedBy: [888],
+        variationCost: 99, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [],
+      },
+    ],
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 0, fieldValues: { 50: { value: 'present' } } },
+      { quantity: 5, fieldValues: {} },
+    ],
+  }) as QuoteResult;
+  // zero-qty group contributes exactly 0 (no +20 setup); other group: 5*10 = 50
+  expect(r.groupCosts).toEqual([0, 50]);
+  expect(r.cost).toBe(50);
+});
+
+test('groupCost preserves 3rd-decimal precision', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    groupFields: [{
+      id: 60, originalId: 60, position: 0, fieldType: 5, independent: false,
+      isSelectable: false, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0.001,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [{ quantity: 3, fieldValues: { 60: { value: 'x' } } }],
+  }) as QuoteResult;
+  // groupCost = 3*10 + 0.001*3 = 30.003, serialized at 3dp (not 2dp)
+  expect(r.groupCosts).toEqual([30.003]);
+});
+
+test('group product: weighted unit price and summed group costs', () => {
+  const rules: PricingRules = { ...base, hasGroups: true };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [{ quantity: 3, fieldValues: {} }, { quantity: 7, fieldValues: {} }],
+  }) as QuoteResult;
+  expect(r.cost).toBe(100);
+  expect(r.groupCosts).toEqual([30, 70]);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('product setupPrice applied once to job', () => {
+  const rules: PricingRules = {
+    ...base,
+    product: {
+      unitPrice: 10, minimumPrice: null, setupPrice: 25,
+      setupPerGroup: false, discountGroup: null,
+    },
+  };
+  const r = estimateQuote(rules, { quantity: 5, fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(75);
+  expect(r.taxAmount).toBe(7.5);
+});
+
+test('product setupPrice applied once across groups when setupPerGroup is false', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10, minimumPrice: null, setupPrice: 25,
+      setupPerGroup: false, discountGroup: null,
+    },
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [{ quantity: 3, fieldValues: {} }, { quantity: 7, fieldValues: {} }],
+  }) as QuoteResult;
+  expect(r.groupCosts).toEqual([30, 70]);
+  expect(r.cost).toBe(125);
+});
+
+test('product setupPrice applied per non-empty group when setupPerGroup is true', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10, minimumPrice: null, setupPrice: 25,
+      setupPerGroup: true, discountGroup: null,
+    },
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 3, fieldValues: {} },
+      { quantity: 0, fieldValues: {} },
+      { quantity: 7, fieldValues: {} },
+    ],
+  }) as QuoteResult;
+  expect(r.groupCosts).toEqual([55, 0, 95]);
+  expect(r.cost).toBe(150);
+});
+
+test('group quantities from form inputs are numeric strings and must not concatenate', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10,
+      minimumPrice: null,
+      discountGroup: {
+        groupRestricted: false,
+        discounts: [{ lowerLimit: 1000, amount: 50 }],
+      },
+    },
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: '100' as unknown as number, fieldValues: {} },
+      { quantity: '1' as unknown as number, fieldValues: {} },
+    ],
+  }) as QuoteResult;
+  // 100+1=101, below the 1000-unit break. String concat would yield "01001"→1001
+  // and incorrectly apply the 50% discount.
+  expect(r.groupCosts).toEqual([1000, 10]);
+  expect(r.cost).toBe(1010);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('group product with no groups array: zero cost', () => {
+  const rules: PricingRules = { ...base, hasGroups: true };
+  const r = estimateQuote(rules, { fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(0);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('zero quantity yields zero cost and no NaN unit price', () => {
+  const r = estimateQuote(base, { quantity: 0, fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(0);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('missing quantity treated as zero', () => {
+  const r = estimateQuote(base, { fieldValues: {} }) as QuoteResult;
+  expect(r.cost).toBe(0);
+});
+
+test('option setup + unit-cost discount groups (non-restricted) applied', () => {
+  const dg = { groupRestricted: false, discounts: [{ lowerLimit: 5, amount: 50 }] };
+  const rules: PricingRules = {
+    ...base,
+    fields: [{
+      id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [{
+        id: 101, originalId: 101, position: 0, default: false,
+        variationCost: 10, variationUnitCost: 2,
+        variationCostDiscountGroup: dg, variationUnitCostDiscountGroup: dg,
+        selectedBy: [],
+      }],
+    }],
+  };
+  const r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [101] } } }) as QuoteResult;
+  // setup: 10 * (1-0.5) = 5; unit: 2 * 0.5 = 1 -> 1*10 = 10; base 100
+  expect(r.cost).toBe(115);
+});
+
+test('unknown selectedOptionId is skipped; originalId lookup matches', () => {
+  const rules: PricingRules = {
+    ...base,
+    fields: [{
+      id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [{
+        id: 101, originalId: 999, position: 0, default: false,
+        variationCost: 3, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+      }],
+    }],
+  };
+  // 999 resolves via originalId (+3 setup); 555 is unknown and skipped
+  const r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [999, 555] } } }) as QuoteResult;
+  expect(r.cost).toBe(103);
+});
+
+test('group product: group fields and group-restricted independent unit cost', () => {
+  const restrictedDg = { groupRestricted: true, discounts: [{ lowerLimit: 5, amount: 50 }] };
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    groupFields: [{
+      id: 10, originalId: 10, position: 0, fieldType: 5, independent: false,
+      isSelectable: false, selectedBy: [],
+      variationCost: 4, variationUnitCost: 1,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+    fields: [{
+      id: 20, originalId: 20, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [],
+      variationCost: 0, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [{
+        id: 120, originalId: 120, position: 0, default: false,
+        variationCost: 0, variationUnitCost: 2,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: restrictedDg,
+        selectedBy: [],
+      }],
+    }],
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: { 20: { selectedOptionIds: [120] } },
+    groups: [
+      { quantity: 3, fieldValues: { 10: { value: 'x' } } },
+      { quantity: 7, fieldValues: {} },
+    ],
+  }) as QuoteResult;
+  // groups base: 3*10 + (4 + 1*3) = 30 + 7 = 37; 7*10 = 70 -> groupCosts [37,70]
+  // independent restricted unit: q3<5 -> 2, q7>=5 -> 1; total 2*3 + 1*7 = 13
+  // cost = 37 + 70 + 13 = 120
+  expect(r.groupCosts).toEqual([37, 70]);
+  expect(r.cost).toBe(120);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('group product: restricted product discount, zero-qty group, hidden fields skipped', () => {
+  const rules: PricingRules = {
+    ...base,
+    hasGroups: true,
+    product: {
+      unitPrice: 10, minimumPrice: null,
+      discountGroup: { groupRestricted: true, discounts: [] },
+    },
+    groupFields: [{
+      id: 30, originalId: 30, position: 0, fieldType: 2, independent: false,
+      isSelectable: true, selectedBy: [888],
+      variationCost: 50, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+    fields: [{
+      id: 40, originalId: 40, position: 0, fieldType: 2, independent: true,
+      isSelectable: true, selectedBy: [888],
+      variationCost: 60, variationUnitCost: 0,
+      variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+      options: [],
+    }],
+  };
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [{ quantity: 0, fieldValues: {} }],
+  }) as QuoteResult;
+  // restricted product discount group (empty discounts -> no change); group qty 0;
+  // both conditional fields hidden (selectedBy [888] unmet) so not costed
+  expect(r.cost).toBe(0);
+  expect(r.groupCosts).toEqual([0]);
+  expect(r.costPerUnit).toBe(10);
+});
+
+test('group field visibility is scoped per group (no cross-group leak)', () => {
+  // Size field (24mm=801, 25mm=802) and a premium group field gated by 25mm
+  // (selectedBy [802]) whose selected option 811 costs 5 setup.
+  const opt = (id: number, selectedBy: number[] = []) => ({
+    id, originalId: id, position: id, default: false,
+    variationCost: 0, variationUnitCost: 0,
+    variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+    selectedBy,
+  });
+  const rules: PricingRules = {
+    ...base, hasGroups: true,
+    product: { unitPrice: 0, minimumPrice: null, discountGroup: null },
+    taxPercent: 0,
+    groupFields: [
+      {
+        id: 800, originalId: 800, position: 0, fieldType: 2, independent: false,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [opt(801), opt(802)],
+      },
+      {
+        id: 810, originalId: 810, position: 1, fieldType: 2, independent: false,
+        isSelectable: true, selectedBy: [802], // gated by 25mm
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: [{ ...opt(811), variationCost: 5 }],
+      },
+    ],
+  };
+  // Group A picks 24mm but ALSO has premium 811 selected; Group B picks 25mm + 811.
+  // Scoped: A's premium field is hidden (24mm) -> 811 NOT costed; B's is visible
+  // -> 811 costs 5. A global resolver would wrongly cost A's 811 too (total 10).
+  const r = estimateQuote(rules, {
+    fieldValues: {},
+    groups: [
+      { quantity: 10, fieldValues: { 800: { selectedOptionIds: [801] }, 810: { selectedOptionIds: [811] } } },
+      { quantity: 10, fieldValues: { 800: { selectedOptionIds: [802] }, 810: { selectedOptionIds: [811] } } },
+    ],
+  }) as QuoteResult;
+  expect(r.groupCosts).toEqual([0, 5]);
+  expect(r.cost).toBe(5);
+});