@adtrackify/at-service-common 5.1.0 → 5.1.2

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

@@ -1,288 +1,303 @@
-import Big from 'big.js';
-import { DateTime } from 'luxon';
-import { Logger } from '../../../helpers/logging-helper.js';
-import { OrderCalculationHelper } from '../../../helpers/order-calculation-helper.js';
-import { CostCalculatorService } from '../cost-calculator-service.js';
-const USE_PROCESSED_AT_FOR_NON_WEB_ORDERS = process?.env?.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS === 'true';
-const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
-const EMPTY_ORDER_COST_RESULT = {
-    orderLevelHandlingCost: 0,
-    lineItemLevelHandlingCost: 0,
-    totalHandlingCost: 0,
-    orderLevelOtherCost: 0,
-    lineItemLevelOtherCost: 0,
-    totalOtherCost: 0,
-    totalGatewayCost: 0,
-    totalShippingCost: 0,
-    lineItemCosts: {},
-    categoryCosts: {
-        totalOtherCogs: 0,
-        otherFulfillmentCost: 0,
-        otherTransactionCost: 0,
-        marketingCost: 0,
-        agencyFeesCost: 0,
-        opexCost: 0,
-        totalOtherCost: 0,
-    },
-};
-export const OrderCostResolutionService = {
-    parseCostWindowEndDate: (effectiveEndDate) => {
-        const parsed = DateTime.fromISO(effectiveEndDate, { zone: 'utc' });
-        return DATE_ONLY_PATTERN.test(effectiveEndDate) ? parsed.endOf('day') : parsed;
-    },
-    sortValidCostHistoryByStartDate: (costHistory) => {
-        try {
-            if (!costHistory || costHistory.length === 0) {
-                return [];
-            }
-            const validCostHistory = costHistory.filter(entry => DateTime.fromISO(entry.effectiveStartDate).isValid);
-            return validCostHistory.sort((a, b) => {
-                const dateA = DateTime.fromISO(a.effectiveStartDate);
-                const dateB = DateTime.fromISO(b.effectiveStartDate);
-                return dateA.toMillis() - dateB.toMillis();
-            });
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.sortValidCostHistoryByStartDate: failed', { error, costHistory });
-            return [];
-        }
-    },
-    findCostHistoryRecordInEffectiveWindow: (costHistory, orderCreatedAt) => {
-        try {
-            if (!orderCreatedAt) {
-                return null;
-            }
-            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
-            if (!orderDateTime.isValid) {
-                return null;
-            }
-            const sortedCostHistory = OrderCostResolutionService.sortValidCostHistoryByStartDate(costHistory);
-            for (const costRecord of sortedCostHistory) {
-                const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate, { zone: 'utc' });
-                if (orderDateTime >= effectiveStartDate) {
-                    if (costRecord.effectiveEndDate === null) {
-                        return costRecord;
-                    }
-                    const effectiveEndDate = OrderCostResolutionService.parseCostWindowEndDate(costRecord.effectiveEndDate);
-                    if (!effectiveEndDate.isValid) {
-                        continue;
-                    }
-                    if (orderDateTime <= effectiveEndDate) {
-                        return costRecord;
-                    }
-                }
-            }
-            return null;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow: failed', { error, orderCreatedAt });
-            return null;
-        }
-    },
-    isValidCost: (cost) => {
-        try {
-            return typeof cost === 'number' && !Number.isNaN(cost) && cost >= 0 && cost <= 1000000;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.isValidCost: failed', { error, cost });
-            return false;
-        }
-    },
-    hasConfirmedShopifyZeroCost: (variantRecord, costRecord, orderCreatedAt) => {
-        try {
-            if (costRecord?.effectiveEndDate !== null || variantRecord?.variant?.inventoryItem?.unitCost !== 0) {
-                return false;
-            }
-            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
-            const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate, { zone: 'utc' });
-            if (!orderDateTime.isValid || !effectiveStartDate.isValid) {
-                return false;
-            }
-            return orderDateTime >= effectiveStartDate;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.hasConfirmedShopifyZeroCost: failed', { error, variantRecord, costRecord, orderCreatedAt });
-            return false;
-        }
-    },
-    resolveOrderLineItemUnitCosts: (lineItems, pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId) => {
-        const result = {};
-        try {
-            const defaultCogsPercent = costConfigsByPixelId[pixelId]?.globalProductOverride?.defaultCogs;
-            let resolvedFromManualCount = 0;
-            let resolvedFromShopifyCount = 0;
-            let defaultCogsFallbackCount = 0;
-            for (const li of lineItems) {
-                const lineItemId = String(li.id);
-                const productId = li.product_id ? String(li.product_id) : '';
-                const variantId = li.variant_id ? String(li.variant_id) : '';
-                const variantKey = `${pixelId}_${productId}_${variantId}`;
-                const variantRecord = variantRecords[variantKey];
-                const lineItemPrice = li.price ? parseFloat(li.price) : 0;
-                const lineItemQuantity = li.quantity ?? 1;
-                if (variantRecord) {
-                    const manualCostRecord = OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(variantRecord.manualCostHistory ?? [], orderCreatedAt);
-                    if (manualCostRecord?.cost !== undefined && OrderCostResolutionService.isValidCost(manualCostRecord.cost)) {
-                        result[lineItemId] = manualCostRecord.cost;
-                        resolvedFromManualCount++;
-                        continue;
-                    }
-                    const shopifyCostHistory = variantRecord.shopifyCostHistory ?? [];
-                    const shopifyCostRecord = OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(shopifyCostHistory, orderCreatedAt);
-                    if (shopifyCostRecord?.cost !== undefined && OrderCostResolutionService.isValidCost(shopifyCostRecord.cost)) {
-                        const shopifyCost = shopifyCostRecord.cost;
-                        const isUnconfirmedZero = shopifyCost === 0 && !OrderCostResolutionService.hasConfirmedShopifyZeroCost(variantRecord, shopifyCostRecord, orderCreatedAt);
-                        if (!isUnconfirmedZero) {
-                            result[lineItemId] = shopifyCost;
-                            resolvedFromShopifyCount++;
-                            continue;
-                        }
-                    }
-                }
-                if (typeof defaultCogsPercent === 'number' && defaultCogsPercent >= 0 && defaultCogsPercent <= 100) {
-                    if (lineItemPrice > 0 && lineItemQuantity > 0) {
-                        const grossSalePrice = new Big(lineItemPrice).times(lineItemQuantity);
-                        const totalCost = grossSalePrice.times(defaultCogsPercent).div(100);
-                        const unitCost = totalCost.div(lineItemQuantity).toNumber();
-                        if (OrderCostResolutionService.isValidCost(unitCost)) {
-                            result[lineItemId] = unitCost;
-                            defaultCogsFallbackCount++;
-                        }
-                    }
-                }
-            }
-            Logger.debug('OrderCostResolutionService.resolveOrderLineItemUnitCosts: complete', {
-                totalLineItems: lineItems.length,
-                resolvedFromManual: resolvedFromManualCount,
-                resolvedFromShopify: resolvedFromShopifyCount,
-                defaultCogsFallback: defaultCogsFallbackCount,
-                totalResolved: Object.keys(result).length,
-            });
-            return result;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.resolveOrderLineItemUnitCosts: failed', { error, pixelId });
-            return result;
-        }
-    },
-    getOrderCreatedAt: (order, useProcessedAtForNonWebOrders = USE_PROCESSED_AT_FOR_NON_WEB_ORDERS) => {
-        try {
-            const isNonWebOrder = order.source_name !== 'web';
-            const shouldOverrideCreatedAt = useProcessedAtForNonWebOrders && isNonWebOrder;
-            if (shouldOverrideCreatedAt) {
-                return order?.processed_at ?? order?.created_at;
-            }
-            return order?.created_at;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getOrderCreatedAt: failed', { error, order });
-            return order?.created_at;
-        }
-    },
-    getTotalProductCost: (order, lineItemUnitCosts) => {
-        try {
-            let totalProductCost = new Big(0);
-            let hasValidCosts = false;
-            order?.line_items?.forEach((lineItem) => {
-                const lineItemId = lineItem.id !== undefined ? String(lineItem.id) : '';
-                if (!lineItemId)
-                    return;
-                const unitCost = lineItemUnitCosts[lineItemId];
-                if (unitCost !== undefined) {
-                    const quantity = lineItem.quantity ?? 0;
-                    totalProductCost = totalProductCost.plus(new Big(unitCost).times(quantity));
-                    hasValidCosts = true;
-                }
-            });
-            return hasValidCosts ? new Big(totalProductCost.toFixed(2)).toNumber() : undefined;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getTotalProductCost: failed', { error });
-            return undefined;
-        }
-    },
-    buildOrderCostContext: (params) => {
-        const { pixelId, order, variantRecords, productRecords, orderCreatedAt, refundInfoByLineItemId, saleTotals } = params;
-        const orderTags = order?.tags?.split(',').map((t) => t.trim()).filter(Boolean) ?? [];
-        const paymentGateways = order?.payment_gateway_names ?? [];
-        const shippingTitles = (order?.shipping_lines?.map((s) => s.title).filter(Boolean) ?? []);
-        const shipCountryCode = order?.shipping_address?.country_code;
-        const orderFilterContext = {
-            tags: orderTags,
-            sourceName: order?.source_name,
-            paymentGateways,
-            shippingTitles,
-            shipCountryCode,
-        };
-        const lineItems = (order?.line_items ?? []).map((li) => {
-            const productId = li?.product_id ? String(li.product_id) : '';
-            const variantId = li?.variant_id ? String(li.variant_id) : '';
-            const variantKey = `${pixelId}_${productId}_${variantId}`;
-            const productKey = `${pixelId}_${productId}`;
-            const variantRecord = variantRecords[variantKey];
-            const productRecord = productRecords[productKey];
-            const filterContext = {
-                vendor: variantRecord?.vendor,
-                productType: variantRecord?.productType,
-                tags: variantRecord?.tags ?? [],
-                category: productRecord?.product?.category?.fullName,
-                productId,
-                variantId,
-            };
-            const lineItemId = li.id !== undefined ? String(li.id) : '';
-            return {
-                lineItemId,
-                quantity: li.quantity ?? 0,
-                refundedQuantity: lineItemId ? (refundInfoByLineItemId?.[lineItemId]?.refundQuantity ?? 0) : 0,
-                filterContext,
-                variantHandlingFee: variantRecord?.handlingFee,
-            };
-        });
-        const totalWeight = order?.total_weight ?? 0;
-        const totalQuantity = lineItems.reduce((sum, li) => sum + li.quantity, 0);
-        const shopifyShippingAmount = parseFloat(String(order?.total_shipping_price_set?.shop_money?.amount ?? '0'));
-        return {
-            orderCreatedAt: orderCreatedAt ?? order?.created_at ?? '',
-            totalPrice: parseFloat(String(order?.total_price_set?.shop_money?.amount ?? '0')),
-            grossSalePrice: saleTotals?.grossSalePrice ?? 0,
-            netSalePrice: saleTotals?.netSalePrice ?? 0,
-            totalProductCost: saleTotals?.totalProductCost ?? 0,
-            totalShipping: shopifyShippingAmount,
-            totalWeight,
-            totalQuantity,
-            hasRefund: (order?.refunds?.length ?? 0) > 0,
-            orderFilterContext,
-            lineItems,
-        };
-    },
-    computeOrderCostResult: (params) => {
-        const { pixelId, order, variantRecords, productRecords, costConfigs, exchangeRatesMap, useProcessedAtForNonWebOrders } = params;
-        try {
-            const orderCurrency = params.orderCurrency ?? order?.currency ?? '';
-            const orderCreatedAt = OrderCostResolutionService.getOrderCreatedAt(order, useProcessedAtForNonWebOrders) ?? order?.created_at ?? '';
-            const costConfigsByPixelId = costConfigs ? { [pixelId]: costConfigs } : {};
-            const lineItemUnitCosts = OrderCostResolutionService.resolveOrderLineItemUnitCosts(order?.line_items ?? [], pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId);
-            const saleTotals = {
-                grossSalePrice: OrderCalculationHelper.getGrossSalePrice(order) ?? 0,
-                netSalePrice: OrderCalculationHelper.getNetSalePrice(order) ?? 0,
-                totalProductCost: OrderCostResolutionService.getTotalProductCost(order, lineItemUnitCosts) ?? 0,
-            };
-            const refundInfoByLineItemId = OrderCalculationHelper.getLineItemsRefundInfo(order);
-            const context = OrderCostResolutionService.buildOrderCostContext({
-                pixelId,
-                order,
-                variantRecords,
-                productRecords,
-                orderCreatedAt,
-                refundInfoByLineItemId,
-                saleTotals,
-            });
-            return CostCalculatorService.calculateOrderCosts(costConfigs, context, orderCurrency, exchangeRatesMap);
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.computeOrderCostResult: failed', { error, pixelId, orderId: order?.id });
-            return EMPTY_ORDER_COST_RESULT;
-        }
-    },
-};
+import Big from 'big.js';
+import { DateTime } from 'luxon';
+import { Logger } from '../../../helpers/logging-helper.js';
+import { OrderCalculationHelper } from '../../../helpers/order-calculation-helper.js';
+import { CostCalculatorService } from '../cost-calculator-service.js';
+const USE_PROCESSED_AT_FOR_NON_WEB_ORDERS = process?.env?.USE_PROCESSED_AT_FOR_NON_WEB_ORDERS === 'true';
+const DATE_ONLY_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const EMPTY_ORDER_COST_RESULT = {
+    orderLevelHandlingCost: 0,
+    lineItemLevelHandlingCost: 0,
+    totalHandlingCost: 0,
+    orderLevelOtherCost: 0,
+    lineItemLevelOtherCost: 0,
+    totalOtherCost: 0,
+    totalGatewayCost: 0,
+    totalShippingCost: 0,
+    lineItemCosts: {},
+    categoryCosts: {
+        totalOtherCogs: 0,
+        otherFulfillmentCost: 0,
+        otherTransactionCost: 0,
+        marketingCost: 0,
+        agencyFeesCost: 0,
+        opexCost: 0,
+        totalOtherCost: 0,
+    },
+};
+export const OrderCostResolutionService = {
+    parseCostWindowEndDate: (effectiveEndDate) => {
+        const parsed = DateTime.fromISO(effectiveEndDate, { zone: 'utc' });
+        return DATE_ONLY_PATTERN.test(effectiveEndDate) ? parsed.endOf('day') : parsed;
+    },
+    sortValidCostHistoryByStartDate: (costHistory) => {
+        try {
+            if (!costHistory || costHistory.length === 0) {
+                return [];
+            }
+            const validCostHistory = costHistory.filter((entry) => DateTime.fromISO(entry.effectiveStartDate).isValid);
+            return validCostHistory.sort((a, b) => {
+                const dateA = DateTime.fromISO(a.effectiveStartDate);
+                const dateB = DateTime.fromISO(b.effectiveStartDate);
+                return dateA.toMillis() - dateB.toMillis();
+            });
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.sortValidCostHistoryByStartDate: failed', { error, costHistory });
+            return [];
+        }
+    },
+    findCostHistoryRecordInEffectiveWindow: (costHistory, orderCreatedAt) => {
+        try {
+            if (!orderCreatedAt) {
+                return null;
+            }
+            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
+            if (!orderDateTime.isValid) {
+                return null;
+            }
+            const sortedCostHistory = OrderCostResolutionService.sortValidCostHistoryByStartDate(costHistory);
+            for (const costRecord of sortedCostHistory) {
+                const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate, { zone: 'utc' });
+                if (orderDateTime >= effectiveStartDate) {
+                    if (costRecord.effectiveEndDate === null) {
+                        return costRecord;
+                    }
+                    const effectiveEndDate = OrderCostResolutionService.parseCostWindowEndDate(costRecord.effectiveEndDate);
+                    if (!effectiveEndDate.isValid) {
+                        continue;
+                    }
+                    if (orderDateTime <= effectiveEndDate) {
+                        return costRecord;
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow: failed', {
+                error,
+                orderCreatedAt,
+            });
+            return null;
+        }
+    },
+    isValidCost: (cost) => {
+        try {
+            return typeof cost === 'number' && !Number.isNaN(cost) && cost >= 0 && cost <= 1000000;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.isValidCost: failed', { error, cost });
+            return false;
+        }
+    },
+    hasConfirmedShopifyZeroCost: (variantRecord, costRecord, orderCreatedAt) => {
+        try {
+            if (costRecord?.effectiveEndDate !== null || variantRecord?.variant?.inventoryItem?.unitCost !== 0) {
+                return false;
+            }
+            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
+            const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate, { zone: 'utc' });
+            if (!orderDateTime.isValid || !effectiveStartDate.isValid) {
+                return false;
+            }
+            return orderDateTime >= effectiveStartDate;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.hasConfirmedShopifyZeroCost: failed', {
+                error,
+                variantRecord,
+                costRecord,
+                orderCreatedAt,
+            });
+            return false;
+        }
+    },
+    resolveOrderLineItemUnitCosts: (lineItems, pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId) => {
+        const result = {};
+        try {
+            const defaultCogsPercent = costConfigsByPixelId[pixelId]?.globalProductOverride?.defaultCogs;
+            let resolvedFromManualCount = 0;
+            let resolvedFromShopifyCount = 0;
+            let defaultCogsFallbackCount = 0;
+            for (const li of lineItems) {
+                const lineItemId = String(li.id);
+                const productId = li.product_id ? String(li.product_id) : '';
+                const variantId = li.variant_id ? String(li.variant_id) : '';
+                const variantKey = `${pixelId}_${productId}_${variantId}`;
+                const variantRecord = variantRecords[variantKey];
+                const lineItemPrice = li.price ? parseFloat(li.price) : 0;
+                const lineItemQuantity = li.quantity ?? 1;
+                if (variantRecord) {
+                    const manualCostRecord = OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(variantRecord.manualCostHistory ?? [], orderCreatedAt);
+                    if (manualCostRecord?.cost !== undefined && OrderCostResolutionService.isValidCost(manualCostRecord.cost)) {
+                        result[lineItemId] = manualCostRecord.cost;
+                        resolvedFromManualCount++;
+                        continue;
+                    }
+                    const shopifyCostHistory = variantRecord.shopifyCostHistory ?? [];
+                    const shopifyCostRecord = OrderCostResolutionService.findCostHistoryRecordInEffectiveWindow(shopifyCostHistory, orderCreatedAt);
+                    if (shopifyCostRecord?.cost !== undefined && OrderCostResolutionService.isValidCost(shopifyCostRecord.cost)) {
+                        const shopifyCost = shopifyCostRecord.cost;
+                        const isUnconfirmedZero = shopifyCost === 0 &&
+                            !OrderCostResolutionService.hasConfirmedShopifyZeroCost(variantRecord, shopifyCostRecord, orderCreatedAt);
+                        if (!isUnconfirmedZero) {
+                            result[lineItemId] = shopifyCost;
+                            resolvedFromShopifyCount++;
+                            continue;
+                        }
+                    }
+                }
+                if (typeof defaultCogsPercent === 'number' && defaultCogsPercent >= 0 && defaultCogsPercent <= 100) {
+                    if (lineItemPrice > 0 && lineItemQuantity > 0) {
+                        const grossSalePrice = new Big(lineItemPrice).times(lineItemQuantity);
+                        const totalCost = grossSalePrice.times(defaultCogsPercent).div(100);
+                        const unitCost = totalCost.div(lineItemQuantity).toNumber();
+                        if (OrderCostResolutionService.isValidCost(unitCost)) {
+                            result[lineItemId] = unitCost;
+                            defaultCogsFallbackCount++;
+                        }
+                    }
+                }
+            }
+            Logger.debug('OrderCostResolutionService.resolveOrderLineItemUnitCosts: complete', {
+                totalLineItems: lineItems.length,
+                resolvedFromManual: resolvedFromManualCount,
+                resolvedFromShopify: resolvedFromShopifyCount,
+                defaultCogsFallback: defaultCogsFallbackCount,
+                totalResolved: Object.keys(result).length,
+            });
+            return result;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.resolveOrderLineItemUnitCosts: failed', { error, pixelId });
+            return result;
+        }
+    },
+    getOrderCreatedAt: (order, useProcessedAtForNonWebOrders = USE_PROCESSED_AT_FOR_NON_WEB_ORDERS) => {
+        try {
+            const isNonWebOrder = order.source_name !== 'web';
+            const shouldOverrideCreatedAt = useProcessedAtForNonWebOrders && isNonWebOrder;
+            if (shouldOverrideCreatedAt) {
+                return order?.processed_at ?? order?.created_at;
+            }
+            return order?.created_at;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getOrderCreatedAt: failed', { error, order });
+            return order?.created_at;
+        }
+    },
+    getTotalProductCost: (order, lineItemUnitCosts) => {
+        try {
+            let totalProductCost = new Big(0);
+            let hasValidCosts = false;
+            order?.line_items?.forEach((lineItem) => {
+                const lineItemId = lineItem.id !== undefined ? String(lineItem.id) : '';
+                if (!lineItemId)
+                    return;
+                const unitCost = lineItemUnitCosts[lineItemId];
+                if (unitCost !== undefined) {
+                    const quantity = lineItem.quantity ?? 0;
+                    totalProductCost = totalProductCost.plus(new Big(unitCost).times(quantity));
+                    hasValidCosts = true;
+                }
+            });
+            return hasValidCosts ? new Big(totalProductCost.toFixed(2)).toNumber() : undefined;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getTotalProductCost: failed', { error });
+            return undefined;
+        }
+    },
+    buildOrderCostContext: (params) => {
+        const { pixelId, order, variantRecords, productRecords, orderCreatedAt, refundInfoByLineItemId, saleTotals } = params;
+        const orderTags = order?.tags
+            ?.split(',')
+            .map((t) => t.trim())
+            .filter(Boolean) ?? [];
+        const paymentGateways = order?.payment_gateway_names ?? [];
+        const shippingTitles = (order?.shipping_lines?.map((s) => s.title).filter(Boolean) ??
+            []);
+        const shipCountryCode = order?.shipping_address?.country_code;
+        const orderFilterContext = {
+            tags: orderTags,
+            sourceName: order?.source_name,
+            paymentGateways,
+            shippingTitles,
+            shipCountryCode,
+        };
+        const lineItems = (order?.line_items ?? []).map((li) => {
+            const productId = li?.product_id ? String(li.product_id) : '';
+            const variantId = li?.variant_id ? String(li.variant_id) : '';
+            const variantKey = `${pixelId}_${productId}_${variantId}`;
+            const productKey = `${pixelId}_${productId}`;
+            const variantRecord = variantRecords[variantKey];
+            const productRecord = productRecords[productKey];
+            const filterContext = {
+                vendor: variantRecord?.vendor,
+                productType: variantRecord?.productType,
+                tags: variantRecord?.tags ?? [],
+                category: productRecord?.product?.category?.fullName,
+                productId,
+                variantId,
+            };
+            const lineItemId = li.id !== undefined ? String(li.id) : '';
+            return {
+                lineItemId,
+                quantity: li.quantity ?? 0,
+                refundedQuantity: lineItemId ? refundInfoByLineItemId?.[lineItemId]?.refundQuantity ?? 0 : 0,
+                filterContext,
+                variantHandlingFee: variantRecord?.handlingFee,
+            };
+        });
+        const totalWeight = order?.total_weight ?? 0;
+        const totalQuantity = lineItems.reduce((sum, li) => sum + li.quantity, 0);
+        const shopifyShippingAmount = parseFloat(String(order?.total_shipping_price_set?.shop_money?.amount ?? '0'));
+        return {
+            orderCreatedAt: orderCreatedAt ?? order?.created_at ?? '',
+            totalPrice: parseFloat(String(order?.total_price_set?.shop_money?.amount ?? '0')),
+            grossSalePrice: saleTotals?.grossSalePrice ?? 0,
+            netSalePrice: saleTotals?.netSalePrice ?? 0,
+            totalProductCost: saleTotals?.totalProductCost ?? 0,
+            totalShipping: shopifyShippingAmount,
+            totalWeight,
+            totalQuantity,
+            hasRefund: (order?.refunds?.length ?? 0) > 0,
+            orderFilterContext,
+            lineItems,
+        };
+    },
+    computeOrderCostResult: (params) => {
+        const { pixelId, order, variantRecords, productRecords, costConfigs, exchangeRatesMap, useProcessedAtForNonWebOrders, } = params;
+        try {
+            const orderCurrency = params.orderCurrency ?? order?.currency ?? '';
+            const orderCreatedAt = OrderCostResolutionService.getOrderCreatedAt(order, useProcessedAtForNonWebOrders) ?? order?.created_at ?? '';
+            const costConfigsByPixelId = costConfigs
+                ? { [pixelId]: costConfigs }
+                : {};
+            const lineItemUnitCosts = OrderCostResolutionService.resolveOrderLineItemUnitCosts(order?.line_items ?? [], pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId);
+            const saleTotals = {
+                grossSalePrice: OrderCalculationHelper.getGrossSalePrice(order) ?? 0,
+                netSalePrice: OrderCalculationHelper.getNetSalePrice(order) ?? 0,
+                totalProductCost: OrderCostResolutionService.getTotalProductCost(order, lineItemUnitCosts) ?? 0,
+            };
+            const refundInfoByLineItemId = OrderCalculationHelper.getLineItemsRefundInfo(order);
+            const context = OrderCostResolutionService.buildOrderCostContext({
+                pixelId,
+                order,
+                variantRecords,
+                productRecords,
+                orderCreatedAt,
+                refundInfoByLineItemId,
+                saleTotals,
+            });
+            return CostCalculatorService.calculateOrderCosts(costConfigs, context, orderCurrency, exchangeRatesMap);
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.computeOrderCostResult: failed', { error, pixelId, orderId: order?.id });
+            return EMPTY_ORDER_COST_RESULT;
+        }
+    },
+};
 //# sourceMappingURL=order-cost-resolution-service.js.map