@adtrackify/at-service-common 4.0.29 → 4.0.32

package/dist/esm/__tests__/services/cost/order-cost/order-cost-resolution-service.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};

package/dist/esm/__tests__/services/cost/order-cost/order-cost-resolution-service.spec.js

@@ -1,205 +1,359 @@
-import { OrderCostResolutionService } from '../../../../services/cost/order-cost/order-cost-resolution-service';
-import { CostCalculatorService } from '../../../../services/cost/cost-calculator-service';
-jest.mock('../../../../helpers/logging-helper', () => ({
-    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
-}));
-const PIXEL_ID = 'pixel-1';
-const createOrder = (overrides = {}) => ({
-    id: 111,
-    currency: 'USD',
-    source_name: 'web',
-    created_at: '2026-06-01T00:00:00Z',
-    line_items: [],
-    refunds: [],
-    ...overrides,
-});
-const lineItem = (over = {}) => ({ id: 1, product_id: 10, variant_id: 20, price: '10.00', quantity: 2, ...over });
-const variantRecord = (over = {}) => ({ pixelId: PIXEL_ID, productId: '10', variantId: '20', ...over });
-const configs = (defaultCogs) => ({ globalProductOverride: defaultCogs === undefined ? null : { defaultCogs }, order: null, gateway: null, shipping: null });
-describe('OrderCostResolutionService', () => {
-    beforeEach(() => jest.clearAllMocks());
-    afterEach(() => jest.restoreAllMocks());
-    describe('getGrossSalePrice', () => {
-        it('sums price * quantity across line items', () => {
-            const order = createOrder({ line_items: [lineItem({ price: '10', quantity: 2 }), lineItem({ price: '5', quantity: 1 })] });
-            expect(OrderCostResolutionService.getGrossSalePrice(order)).toBe(25);
-        });
-        it('returns 0 for no line items', () => {
-            expect(OrderCostResolutionService.getGrossSalePrice(createOrder())).toBe(0);
-        });
-    });
-    describe('getTotalRefundsFromOrder', () => {
-        it('sums successful transaction amounts', () => {
-            const order = createOrder({ refunds: [{ transactions: [{ status: 'success', amount: '10.00' }, { status: 'success', amount: '5.00' }] }] });
-            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(15);
-        });
-        it('ignores non-success transactions', () => {
-            const order = createOrder({ refunds: [{ transactions: [{ status: 'failure', amount: '10.00' }] }] });
-            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(0);
-        });
-        it('applies receipt exchange_rate (amount * rate / 100)', () => {
-            const order = createOrder({ refunds: [{ transactions: [{ status: 'success', amount: '100', receipt: { balance_transaction: { exchange_rate: 50 } } }] }] });
-            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(50);
-        });
-    });
-    describe('getNetSalePrice', () => {
-        it('net = gross - (refunds + discounts)', () => {
-            const order = createOrder({
-                line_items: [lineItem({ price: '10', quantity: 2 })],
-                total_discounts_set: { shop_money: { amount: '5' } },
-                refunds: [{ transactions: [{ status: 'success', amount: '3' }] }],
-            });
-            expect(OrderCostResolutionService.getNetSalePrice(order)).toBe(12);
-        });
-    });
-    describe('getTotalProductCost', () => {
-        it('sums unitCost * quantity for line items with a resolved cost', () => {
-            const order = createOrder({ line_items: [lineItem({ id: 1, quantity: 2 }), lineItem({ id: 2, quantity: 3 })] });
-            expect(OrderCostResolutionService.getTotalProductCost(order, { 1: 3, 2: 1 })).toBe(9);
-        });
-        it('returns undefined when no line item has a cost', () => {
-            const order = createOrder({ line_items: [lineItem({ id: 1, quantity: 2 })] });
-            expect(OrderCostResolutionService.getTotalProductCost(order, {})).toBeUndefined();
-        });
-    });
-    describe('getLineItemsRefundInfo', () => {
-        it('allocates refund quantity + amount (subtotal + total_tax) per line item', () => {
-            const order = createOrder({
-                line_items: [lineItem({ id: 1 })],
-                refunds: [{
-                        transactions: [{ status: 'success', amount: '11' }],
-                        refund_line_items: [{ line_item_id: 1, quantity: 1, subtotal: '10', total_tax: '1' }],
-                    }],
-            });
-            const info = OrderCostResolutionService.getLineItemsRefundInfo(order);
-            expect(info[1]).toEqual({ hasRefund: true, refundQuantity: 1, refundAmount: 11 });
-        });
-    });
-    describe('getOrderCreatedAt', () => {
-        it('returns created_at for web orders', () => {
-            expect(OrderCostResolutionService.getOrderCreatedAt(createOrder({ source_name: 'web', created_at: 'c', processed_at: 'p' }))).toBe('c');
-        });
-        it('uses processed_at for non-web orders only when the flag is set', () => {
-            const order = createOrder({ source_name: 'pos', created_at: 'c', processed_at: 'p' });
-            expect(OrderCostResolutionService.getOrderCreatedAt(order, true)).toBe('p');
-            expect(OrderCostResolutionService.getOrderCreatedAt(order, false)).toBe('c');
-        });
-    });
-    describe('isValidCost', () => {
-        it('accepts 0..1_000_000, rejects negatives / over-max / NaN', () => {
-            expect(OrderCostResolutionService.isValidCost(5)).toBe(true);
-            expect(OrderCostResolutionService.isValidCost(-1)).toBe(false);
-            expect(OrderCostResolutionService.isValidCost(2000000)).toBe(false);
-            expect(OrderCostResolutionService.isValidCost(Number.NaN)).toBe(false);
-        });
-    });
-    describe('selectCostHistoryRecordForOrderDate', () => {
-        const history = [
-            { effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: '2026-03-31T00:00:00Z', cost: 3 },
-            { effectiveStartDate: '2026-04-01T00:00:00Z', effectiveEndDate: null, cost: 5 },
-        ];
-        it('returns the record whose range contains the order date', () => {
-            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '2026-02-15T00:00:00Z')?.cost).toBe(3);
-        });
-        it('returns an open-ended (null end) record', () => {
-            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '2026-06-01T00:00:00Z')?.cost).toBe(5);
-        });
-        it('returns null for empty history or invalid date', () => {
-            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate([], '2026-06-01T00:00:00Z')).toBeNull();
-            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '')).toBeNull();
-        });
-    });
-    describe('resolveOrderLineItemUnitCosts', () => {
-        const byPixel = (defaultCogs) => ({ [PIXEL_ID]: configs(defaultCogs) });
-        it('resolves unit cost from variant shopifyCostHistory', () => {
-            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ shopifyCostHistory: [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }] }) };
-            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel());
-            expect(result).toEqual({ '1': 4 });
-        });
-        it('falls back to defaultCogs percent of line price when no variant cost', () => {
-            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', {}, byPixel(50));
-            expect(result).toEqual({ '1': 5 });
-        });
-        it('resolves nothing when no variant cost and no defaultCogs', () => {
-            expect(OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', {}, byPixel())).toEqual({});
-        });
-    });
-    describe('buildOrderCostContext', () => {
-        it('maps product attributes + refund quantity + totals from records', () => {
-            const order = createOrder({
-                line_items: [lineItem({ id: 1, product_id: 10, variant_id: 20, quantity: 2 })],
-                tags: 'vip, sale',
-                payment_gateway_names: ['shopify_payments'],
-                shipping_lines: [{ title: 'Standard' }],
-                shipping_address: { country_code: 'US' },
-                total_weight: 500,
-                total_shipping_price_set: { shop_money: { amount: '7.50' } },
-                total_price_set: { shop_money: { amount: '20.00' } },
-                refunds: [{ id: 1 }],
-            });
-            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ vendor: 'Acme', productType: 'Shirt', tags: ['cotton'], handlingFee: 1.5 }) };
-            const products = { [`${PIXEL_ID}_10`]: { pixelId: PIXEL_ID, productId: '10', product: { category: { fullName: 'Apparel > Tops' } } } };
-            const ctx = OrderCostResolutionService.buildOrderCostContext({
-                pixelId: PIXEL_ID,
-                order,
-                variantRecords: variants,
-                productRecords: products,
-                orderCreatedAt: order.created_at,
-                refundInfoByLineItemId: { '1': { refundQuantity: 1 } },
-                saleTotals: { grossSalePrice: 20, netSalePrice: 18, totalProductCost: 6 },
-            });
-            expect(ctx.orderFilterContext).toMatchObject({ tags: ['vip', 'sale'], paymentGateways: ['shopify_payments'], shippingTitles: ['Standard'], shipCountryCode: 'US', sourceName: 'web' });
-            expect(ctx.grossSalePrice).toBe(20);
-            expect(ctx.netSalePrice).toBe(18);
-            expect(ctx.totalProductCost).toBe(6);
-            expect(ctx.totalShipping).toBe(7.5);
-            expect(ctx.totalWeight).toBe(500);
-            expect(ctx.totalQuantity).toBe(2);
-            expect(ctx.hasRefund).toBe(true);
-            expect(ctx.lineItems[0]).toMatchObject({
-                lineItemId: '1',
-                quantity: 2,
-                refundedQuantity: 1,
-                variantHandlingFee: 1.5,
-                filterContext: { vendor: 'Acme', productType: 'Shirt', tags: ['cotton'], category: 'Apparel > Tops', productId: '10', variantId: '20' },
-            });
-        });
-    });
-    describe('computeOrderCostResult', () => {
-        const emptyRates = {};
-        it('composes the pipeline and calls calculateOrderCosts with the resolved context', () => {
-            const order = createOrder({
-                currency: 'CAD',
-                line_items: [lineItem({ id: 1, price: '10', quantity: 2 })],
-                total_discounts_set: { shop_money: { amount: '4' } },
-            });
-            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ shopifyCostHistory: [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 3 }] }) };
-            const spy = jest.spyOn(CostCalculatorService, 'calculateOrderCosts').mockReturnValue({ tag: 'result' });
-            const result = OrderCostResolutionService.computeOrderCostResult({
-                pixelId: PIXEL_ID, order, variantRecords: variants, productRecords: {}, costConfigs: configs(), exchangeRatesMap: emptyRates,
-            });
-            expect(result).toEqual({ tag: 'result' });
-            expect(spy).toHaveBeenCalledTimes(1);
-            const [configsArg, contextArg, currencyArg, ratesArg] = spy.mock.calls[0];
-            expect(configsArg).toEqual(configs());
-            expect(currencyArg).toBe('CAD');
-            expect(ratesArg).toBe(emptyRates);
-            const ctx = contextArg;
-            expect(ctx.grossSalePrice).toBe(20);
-            expect(ctx.netSalePrice).toBe(16);
-            expect(ctx.totalProductCost).toBe(6);
-            expect(ctx.totalQuantity).toBe(2);
-        });
-        it('returns a zeroed OrderCostResult when calculation throws (fail-safe)', () => {
-            jest.spyOn(CostCalculatorService, 'calculateOrderCosts').mockImplementation(() => { throw new Error('boom'); });
-            const result = OrderCostResolutionService.computeOrderCostResult({
-                pixelId: PIXEL_ID, order: createOrder({ line_items: [lineItem()] }), variantRecords: {}, productRecords: {}, costConfigs: null, exchangeRatesMap: {},
-            });
-            expect(result.totalHandlingCost).toBe(0);
-            expect(result.totalShippingCost).toBe(0);
-            expect(result.lineItemCosts).toEqual({});
-            expect(result.categoryCosts.totalOtherCogs).toBe(0);
-        });
-    });
-});
+import { OrderCostResolutionService } from '../../../../services/cost/order-cost/order-cost-resolution-service';
+import { CostCalculatorService } from '../../../../services/cost/cost-calculator-service';
+jest.mock('../../../../helpers/logging-helper', () => ({
+    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const PIXEL_ID = 'pixel-1';
+const createOrder = (overrides = {}) => ({
+    id: 111,
+    currency: 'USD',
+    source_name: 'web',
+    created_at: '2026-06-01T00:00:00Z',
+    line_items: [],
+    refunds: [],
+    ...overrides,
+});
+const lineItem = (over = {}) => ({ id: 1, product_id: 10, variant_id: 20, price: '10.00', quantity: 2, ...over });
+const variantRecord = (over = {}) => ({ pixelId: PIXEL_ID, productId: '10', variantId: '20', ...over });
+const configs = (defaultCogs) => ({ globalProductOverride: defaultCogs === undefined ? null : { defaultCogs }, order: null, gateway: null, shipping: null });
+describe('OrderCostResolutionService', () => {
+    beforeEach(() => jest.clearAllMocks());
+    afterEach(() => jest.restoreAllMocks());
+    describe('getGrossSalePrice', () => {
+        it('sums price * quantity across line items', () => {
+            const order = createOrder({ line_items: [lineItem({ price: '10', quantity: 2 }), lineItem({ price: '5', quantity: 1 })] });
+            expect(OrderCostResolutionService.getGrossSalePrice(order)).toBe(25);
+        });
+        it('returns 0 for no line items', () => {
+            expect(OrderCostResolutionService.getGrossSalePrice(createOrder())).toBe(0);
+        });
+    });
+    describe('getTotalRefundsFromOrder', () => {
+        it('sums successful transaction amounts', () => {
+            const order = createOrder({ refunds: [{ transactions: [{ status: 'success', amount: '10.00' }, { status: 'success', amount: '5.00' }] }] });
+            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(15);
+        });
+        it('ignores non-success transactions', () => {
+            const order = createOrder({ refunds: [{ transactions: [{ status: 'failure', amount: '10.00' }] }] });
+            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(0);
+        });
+        it('applies receipt exchange_rate (amount * rate / 100)', () => {
+            const order = createOrder({ refunds: [{ transactions: [{ status: 'success', amount: '100', receipt: { balance_transaction: { exchange_rate: 50 } } }] }] });
+            expect(OrderCostResolutionService.getTotalRefundsFromOrder(order)).toBe(50);
+        });
+    });
+    describe('getNetSalePrice', () => {
+        it('net = gross - (refunds + discounts)', () => {
+            const order = createOrder({
+                line_items: [lineItem({ price: '10', quantity: 2 })],
+                total_discounts_set: { shop_money: { amount: '5' } },
+                refunds: [{ transactions: [{ status: 'success', amount: '3' }] }],
+            });
+            expect(OrderCostResolutionService.getNetSalePrice(order)).toBe(12);
+        });
+    });
+    describe('getTotalProductCost', () => {
+        it('sums unitCost * quantity for line items with a resolved cost', () => {
+            const order = createOrder({ line_items: [lineItem({ id: 1, quantity: 2 }), lineItem({ id: 2, quantity: 3 })] });
+            expect(OrderCostResolutionService.getTotalProductCost(order, { 1: 3, 2: 1 })).toBe(9);
+        });
+        it('returns undefined when no line item has a cost', () => {
+            const order = createOrder({ line_items: [lineItem({ id: 1, quantity: 2 })] });
+            expect(OrderCostResolutionService.getTotalProductCost(order, {})).toBeUndefined();
+        });
+    });
+    describe('getLineItemsRefundInfo', () => {
+        it('allocates refund quantity + amount (subtotal + total_tax) per line item', () => {
+            const order = createOrder({
+                line_items: [lineItem({ id: 1 })],
+                refunds: [{
+                        transactions: [{ status: 'success', amount: '11' }],
+                        refund_line_items: [{ line_item_id: 1, quantity: 1, subtotal: '10', total_tax: '1' }],
+                    }],
+            });
+            const info = OrderCostResolutionService.getLineItemsRefundInfo(order);
+            expect(info[1]).toEqual({ hasRefund: true, refundQuantity: 1, refundAmount: 11 });
+        });
+    });
+    describe('getOrderCreatedAt', () => {
+        it('returns created_at for web orders', () => {
+            expect(OrderCostResolutionService.getOrderCreatedAt(createOrder({ source_name: 'web', created_at: 'c', processed_at: 'p' }))).toBe('c');
+        });
+        it('uses processed_at for non-web orders only when the flag is set', () => {
+            const order = createOrder({ source_name: 'pos', created_at: 'c', processed_at: 'p' });
+            expect(OrderCostResolutionService.getOrderCreatedAt(order, true)).toBe('p');
+            expect(OrderCostResolutionService.getOrderCreatedAt(order, false)).toBe('c');
+        });
+        describe('USE_PROCESSED_AT_FOR_NON_WEB_ORDERS env default', () => {
+            const originalFlag = process.env.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS;
+            const nonWebOrder = createOrder({ source_name: 'pos', created_at: 'c', processed_at: 'p' });
+            const loadService = (flag) => {
+                jest.resetModules();
+                if (flag === undefined) {
+                    delete process.env.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS;
+                }
+                else {
+                    process.env.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS = flag;
+                }
+                return require('../../../../services/cost/order-cost/order-cost-resolution-service').OrderCostResolutionService;
+            };
+            afterAll(() => {
+                if (originalFlag === undefined) {
+                    delete process.env.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS;
+                }
+                else {
+                    process.env.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS = originalFlag;
+                }
+                jest.resetModules();
+            });
+            it('defaults to the env flag when no argument is passed', () => {
+                expect(loadService('true').getOrderCreatedAt(nonWebOrder)).toBe('p');
+            });
+            it('uses created_at when the env flag is unset or not "true"', () => {
+                expect(loadService(undefined).getOrderCreatedAt(nonWebOrder)).toBe('c');
+                expect(loadService('false').getOrderCreatedAt(nonWebOrder)).toBe('c');
+            });
+            it('lets an explicit argument override the env flag in both directions', () => {
+                expect(loadService('true').getOrderCreatedAt(nonWebOrder, false)).toBe('c');
+                expect(loadService('false').getOrderCreatedAt(nonWebOrder, true)).toBe('p');
+            });
+            it('never overrides for web orders regardless of the env flag', () => {
+                const webOrder = createOrder({ source_name: 'web', created_at: 'c', processed_at: 'p' });
+                expect(loadService('true').getOrderCreatedAt(webOrder)).toBe('c');
+            });
+        });
+    });
+    describe('isValidCost', () => {
+        it('accepts 0..1_000_000, rejects negatives / over-max / NaN', () => {
+            expect(OrderCostResolutionService.isValidCost(5)).toBe(true);
+            expect(OrderCostResolutionService.isValidCost(-1)).toBe(false);
+            expect(OrderCostResolutionService.isValidCost(2000000)).toBe(false);
+            expect(OrderCostResolutionService.isValidCost(Number.NaN)).toBe(false);
+        });
+    });
+    describe('selectCostHistoryRecordForOrderDate', () => {
+        const history = [
+            { effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: '2026-03-31T00:00:00Z', cost: 3 },
+            { effectiveStartDate: '2026-04-01T00:00:00Z', effectiveEndDate: null, cost: 5 },
+        ];
+        it('returns the record whose range contains the order date', () => {
+            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '2026-02-15T00:00:00Z')?.cost).toBe(3);
+        });
+        it('returns an open-ended (null end) record', () => {
+            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '2026-06-01T00:00:00Z')?.cost).toBe(5);
+        });
+        it('returns null for empty history or invalid date', () => {
+            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate([], '2026-06-01T00:00:00Z')).toBeNull();
+            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '')).toBeNull();
+        });
+        it('falls back to the earliest entry when the order date precedes every window', () => {
+            expect(OrderCostResolutionService.selectCostHistoryRecordForOrderDate(history, '2025-01-01T00:00:00Z')?.cost).toBe(3);
+        });
+    });
+    describe('hasConfirmedShopifyZeroCost', () => {
+        const withUnitCost = (inventoryItem) => variantRecord({ variant: (inventoryItem === undefined ? {} : { inventoryItem }) });
+        const openEntry = { effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 };
+        const closedEntry = { effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: '2026-03-01T00:00:00Z', cost: 0 };
+        it('confirms only the open-ended entry when Shopify reports exactly 0', () => {
+            expect(OrderCostResolutionService.hasConfirmedShopifyZeroCost(withUnitCost({ unitCost: 0 }), openEntry)).toBe(true);
+            expect(OrderCostResolutionService.hasConfirmedShopifyZeroCost(withUnitCost({ unitCost: 5 }), openEntry)).toBe(false);
+        });
+        it('never confirms a closed entry, since the payload only describes the current period', () => {
+            expect(OrderCostResolutionService.hasConfirmedShopifyZeroCost(withUnitCost({ unitCost: 0 }), closedEntry)).toBe(false);
+        });
+        it('is false when the unit cost or inventory item is absent', () => {
+            expect(OrderCostResolutionService.hasConfirmedShopifyZeroCost(withUnitCost({}), openEntry)).toBe(false);
+            expect(OrderCostResolutionService.hasConfirmedShopifyZeroCost(withUnitCost(), openEntry)).toBe(false);
+        });
+    });
+    describe('findCostHistoryRecordInEffectiveWindow', () => {
+        const windowedHistory = [
+            { effectiveStartDate: '2026-03-01T00:00:00Z', effectiveEndDate: '2026-03-31T00:00:00Z', cost: 7 },
+        ];
+        it('returns the record when the order date is inside the window', () => {
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(windowedHistory, '2026-03-15T00:00:00Z')?.cost).toBe(7);
+        });
+        it('returns null when the order date is before the window', () => {
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(windowedHistory, '2026-01-15T00:00:00Z')).toBeNull();
+        });
+        it('returns null when the order date is after the window', () => {
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(windowedHistory, '2026-06-15T00:00:00Z')).toBeNull();
+        });
+        it('matches an open-ended window', () => {
+            const openEnded = [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 9 }];
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(openEnded, '2026-12-01T00:00:00Z')?.cost).toBe(9);
+        });
+        it('returns null for empty history or invalid date', () => {
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow([], '2026-06-01T00:00:00Z')).toBeNull();
+            expect(OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(windowedHistory, '')).toBeNull();
+        });
+    });
+    describe('resolveOrderLineItemUnitCosts', () => {
+        const byPixel = (defaultCogs) => ({ [PIXEL_ID]: configs(defaultCogs) });
+        it('resolves unit cost from variant shopifyCostHistory', () => {
+            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ shopifyCostHistory: [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }] }) };
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel());
+            expect(result).toEqual({ '1': 4 });
+        });
+        it('falls back to defaultCogs percent of line price when no variant cost', () => {
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', {}, byPixel(50));
+            expect(result).toEqual({ '1': 5 });
+        });
+        it('resolves nothing when no variant cost and no defaultCogs', () => {
+            expect(OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', {}, byPixel())).toEqual({});
+        });
+        const withHistories = (manual, shopify, unitCost) => ({
+            [`${PIXEL_ID}_10_20`]: variantRecord({
+                manualCostHistory: manual,
+                shopifyCostHistory: (shopify ?? []),
+                variant: { inventoryItem: unitCost === undefined ? {} : { unitCost } },
+            }),
+        });
+        it('prefers manual cost over shopify cost for the same order date', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 8 }], [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 8 });
+        });
+        it('prefers manual cost over defaultCogs', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 8 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 8 });
+        });
+        it('falls through to shopify cost when the order date is outside the manual window', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-03-01T00:00:00Z', effectiveEndDate: '2026-03-31T00:00:00Z', cost: 8 }], [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-01-15T00:00:00Z', variants, byPixel());
+            expect(result).toEqual({ '1': 4 });
+        });
+        it('honours a manual cost of 0 instead of falling through to defaultCogs', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 0 });
+        });
+        it('honours a shopify cost of 0 when the payload confirms a zero unit cost', () => {
+            const variants = withHistories(undefined, [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }], 0);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 0 });
+        });
+        it('does not confirm a closed shopify zero row from the current payload', () => {
+            const variants = withHistories(undefined, [
+                { effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: '2026-03-01T00:00:00Z', cost: 0 },
+                { effectiveStartDate: '2026-03-02T00:00:00Z', effectiveEndDate: null, cost: 0 },
+            ], 0);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-02-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 5 });
+        });
+        it('falls through to defaultCogs for a legacy shopify cost of 0 with no unit cost on the payload', () => {
+            const variants = withHistories(undefined, [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 5 });
+        });
+        it('resolves nothing for a legacy shopify cost of 0 when there is no defaultCogs to fall back to', () => {
+            const variants = withHistories(undefined, [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel());
+            expect(result).toEqual({});
+        });
+        it('still prefers a manual cost of 0 over an unconfirmed shopify zero', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }], [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 0 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 0 });
+        });
+        it('falls through to defaultCogs when the shopify entry has no cost at all', () => {
+            const variants = withHistories(undefined, [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem({ price: '10', quantity: 2 })], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel(50));
+            expect(result).toEqual({ '1': 5 });
+        });
+        it('falls through to shopify cost when the manual entry has no cost at all', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null }], [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel());
+            expect(result).toEqual({ '1': 4 });
+        });
+        it('falls through to shopify cost when manualCostHistory is empty or undefined', () => {
+            const shopify = [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }];
+            expect(OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', withHistories([], shopify), byPixel())).toEqual({ '1': 4 });
+            expect(OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', withHistories(undefined, shopify), byPixel())).toEqual({ '1': 4 });
+        });
+        it('ignores an invalid manual cost and falls through to shopify cost', () => {
+            const variants = withHistories([{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: -5 }], [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 4 }]);
+            const result = OrderCostResolutionService.resolveOrderLineItemUnitCosts([lineItem()], PIXEL_ID, '2026-06-01T00:00:00Z', variants, byPixel());
+            expect(result).toEqual({ '1': 4 });
+        });
+    });
+    describe('buildOrderCostContext', () => {
+        it('maps product attributes + refund quantity + totals from records', () => {
+            const order = createOrder({
+                line_items: [lineItem({ id: 1, product_id: 10, variant_id: 20, quantity: 2 })],
+                tags: 'vip, sale',
+                payment_gateway_names: ['shopify_payments'],
+                shipping_lines: [{ title: 'Standard' }],
+                shipping_address: { country_code: 'US' },
+                total_weight: 500,
+                total_shipping_price_set: { shop_money: { amount: '7.50' } },
+                total_price_set: { shop_money: { amount: '20.00' } },
+                refunds: [{ id: 1 }],
+            });
+            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ vendor: 'Acme', productType: 'Shirt', tags: ['cotton'], handlingFee: 1.5 }) };
+            const products = { [`${PIXEL_ID}_10`]: { pixelId: PIXEL_ID, productId: '10', product: { category: { fullName: 'Apparel > Tops' } } } };
+            const ctx = OrderCostResolutionService.buildOrderCostContext({
+                pixelId: PIXEL_ID,
+                order,
+                variantRecords: variants,
+                productRecords: products,
+                orderCreatedAt: order.created_at,
+                refundInfoByLineItemId: { '1': { refundQuantity: 1 } },
+                saleTotals: { grossSalePrice: 20, netSalePrice: 18, totalProductCost: 6 },
+            });
+            expect(ctx.orderFilterContext).toMatchObject({ tags: ['vip', 'sale'], paymentGateways: ['shopify_payments'], shippingTitles: ['Standard'], shipCountryCode: 'US', sourceName: 'web' });
+            expect(ctx.grossSalePrice).toBe(20);
+            expect(ctx.netSalePrice).toBe(18);
+            expect(ctx.totalProductCost).toBe(6);
+            expect(ctx.totalShipping).toBe(7.5);
+            expect(ctx.totalWeight).toBe(500);
+            expect(ctx.totalQuantity).toBe(2);
+            expect(ctx.hasRefund).toBe(true);
+            expect(ctx.lineItems[0]).toMatchObject({
+                lineItemId: '1',
+                quantity: 2,
+                refundedQuantity: 1,
+                variantHandlingFee: 1.5,
+                filterContext: { vendor: 'Acme', productType: 'Shirt', tags: ['cotton'], category: 'Apparel > Tops', productId: '10', variantId: '20' },
+            });
+        });
+    });
+    describe('computeOrderCostResult', () => {
+        const emptyRates = {};
+        it('composes the pipeline and calls calculateOrderCosts with the resolved context', () => {
+            const order = createOrder({
+                currency: 'CAD',
+                line_items: [lineItem({ id: 1, price: '10', quantity: 2 })],
+                total_discounts_set: { shop_money: { amount: '4' } },
+            });
+            const variants = { [`${PIXEL_ID}_10_20`]: variantRecord({ shopifyCostHistory: [{ effectiveStartDate: '2026-01-01T00:00:00Z', effectiveEndDate: null, cost: 3 }] }) };
+            const spy = jest.spyOn(CostCalculatorService, 'calculateOrderCosts').mockReturnValue({ tag: 'result' });
+            const result = OrderCostResolutionService.computeOrderCostResult({
+                pixelId: PIXEL_ID, order, variantRecords: variants, productRecords: {}, costConfigs: configs(), exchangeRatesMap: emptyRates,
+            });
+            expect(result).toEqual({ tag: 'result' });
+            expect(spy).toHaveBeenCalledTimes(1);
+            const [configsArg, contextArg, currencyArg, ratesArg] = spy.mock.calls[0];
+            expect(configsArg).toEqual(configs());
+            expect(currencyArg).toBe('CAD');
+            expect(ratesArg).toBe(emptyRates);
+            const ctx = contextArg;
+            expect(ctx.grossSalePrice).toBe(20);
+            expect(ctx.netSalePrice).toBe(16);
+            expect(ctx.totalProductCost).toBe(6);
+            expect(ctx.totalQuantity).toBe(2);
+        });
+        it('returns a zeroed OrderCostResult when calculation throws (fail-safe)', () => {
+            jest.spyOn(CostCalculatorService, 'calculateOrderCosts').mockImplementation(() => { throw new Error('boom'); });
+            const result = OrderCostResolutionService.computeOrderCostResult({
+                pixelId: PIXEL_ID, order: createOrder({ line_items: [lineItem()] }), variantRecords: {}, productRecords: {}, costConfigs: null, exchangeRatesMap: {},
+            });
+            expect(result.totalHandlingCost).toBe(0);
+            expect(result.totalShippingCost).toBe(0);
+            expect(result.lineItemCosts).toEqual({});
+            expect(result.categoryCosts.totalOtherCogs).toBe(0);
+        });
+    });
+});
 //# sourceMappingURL=order-cost-resolution-service.spec.js.map