@adtrackify/at-service-common 4.0.25 → 4.0.28

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

@@ -1,356 +1,356 @@
-import Big from 'big.js';
-import { DateTime } from 'luxon';
-import { Logger } from '../../../helpers/logging-helper.js';
-import { CostCalculatorService } from '../cost-calculator-service.js';
-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 = {
-    selectCostHistoryRecordForOrderDate: (costHistory, orderCreatedAt) => {
-        try {
-            if (!costHistory || costHistory.length === 0) {
-                return null;
-            }
-            if (!orderCreatedAt) {
-                return null;
-            }
-            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
-            if (!orderDateTime.isValid) {
-                return null;
-            }
-            const validCostHistory = costHistory.filter(entry => DateTime.fromISO(entry.effectiveStartDate).isValid);
-            if (validCostHistory.length === 0) {
-                return null;
-            }
-            const sortedCostHistory = [...validCostHistory].sort((a, b) => {
-                const dateA = DateTime.fromISO(a.effectiveStartDate);
-                const dateB = DateTime.fromISO(b.effectiveStartDate);
-                return dateA.toMillis() - dateB.toMillis();
-            });
-            for (const costRecord of sortedCostHistory) {
-                const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate);
-                if (orderDateTime >= effectiveStartDate) {
-                    if (costRecord.effectiveEndDate === null) {
-                        return costRecord;
-                    }
-                    const effectiveEndDate = DateTime.fromISO(costRecord.effectiveEndDate);
-                    if (!effectiveEndDate.isValid) {
-                        continue;
-                    }
-                    if (orderDateTime <= effectiveEndDate) {
-                        return costRecord;
-                    }
-                }
-            }
-            return sortedCostHistory.length > 0 ? sortedCostHistory[0] : null;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.selectCostHistoryRecordForOrderDate: 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;
-        }
-    },
-    resolveOrderLineItemUnitCosts: (lineItems, pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId) => {
-        const result = {};
-        try {
-            const defaultCogsPercent = costConfigsByPixelId[pixelId]?.globalProductOverride?.defaultCogs;
-            let resolvedFromHistoryCount = 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 costHistory = variantRecord.shopifyCostHistory ?? [];
-                    const applicableCostRecord = OrderCostResolutionService.selectCostHistoryRecordForOrderDate(costHistory, orderCreatedAt);
-                    if (applicableCostRecord?.cost !== undefined) {
-                        const cost = applicableCostRecord.cost;
-                        if (cost > 0 && OrderCostResolutionService.isValidCost(cost)) {
-                            result[lineItemId] = cost;
-                            resolvedFromHistoryCount++;
-                            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,
-                resolvedFromHistory: resolvedFromHistoryCount,
-                defaultCogsFallback: defaultCogsFallbackCount,
-                totalResolved: Object.keys(result).length,
-            });
-            return result;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.resolveOrderLineItemUnitCosts: failed', { error, pixelId });
-            return result;
-        }
-    },
-    getOrderCreatedAt: (order, useProcessedAtForNonWebOrders = false) => {
-        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;
-        }
-    },
-    getGrossSalePrice: (order) => {
-        try {
-            let grossSalePrice = 0;
-            order?.line_items?.forEach((lineItem) => {
-                const lineItemPrice = parseFloat(lineItem?.price ?? '0');
-                const quantity = lineItem?.quantity ?? 0;
-                const lineItemSalePrice = lineItemPrice * quantity;
-                if (lineItemSalePrice) {
-                    grossSalePrice += lineItemSalePrice;
-                }
-            });
-            return grossSalePrice;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getGrossSalePrice: failed', { error });
-            return undefined;
-        }
-    },
-    getTotalRefundsFromOrder: (order) => {
-        try {
-            const sumBig = (values) => values.reduce((acc, v) => acc.plus(v), new Big(0));
-            const refundAmounts = order?.refunds?.map((refund) => {
-                const refunds = refund?.transactions?.map((t) => {
-                    if (t.status === 'success' && t.amount) {
-                        const receipt = t?.receipt;
-                        const exchangeRate = receipt?.balance_transaction?.exchange_rate;
-                        if (exchangeRate) {
-                            return new Big(t.amount).times(exchangeRate).div(100);
-                        }
-                        else {
-                            return new Big(t.amount);
-                        }
-                    }
-                    else {
-                        return new Big(0);
-                    }
-                });
-                return sumBig(refunds ?? []);
-            });
-            const refund = sumBig(refundAmounts ?? []).toFixed(2);
-            return parseFloat(refund);
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getTotalRefundsFromOrder: failed', { error });
-            return 0;
-        }
-    },
-    getNetSalePrice: (order) => {
-        try {
-            let netSalePrice;
-            const grossSalePrice = OrderCostResolutionService.getGrossSalePrice(order);
-            const totalRefunds = OrderCostResolutionService.getTotalRefundsFromOrder(order);
-            let totalDiscounts = 0;
-            if (order?.total_discounts_set?.shop_money?.amount) {
-                totalDiscounts = parseFloat(order?.total_discounts_set?.shop_money?.amount ?? '0');
-            }
-            if (grossSalePrice) {
-                netSalePrice = grossSalePrice - (totalRefunds + totalDiscounts);
-            }
-            return netSalePrice;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getNetSalePrice: failed', { error });
-            return undefined;
-        }
-    },
-    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;
-        }
-    },
-    getLineItemsRefundInfo: (order) => {
-        try {
-            const lineItemRefunds = {};
-            order?.line_items?.forEach((li) => {
-                if (li.id !== undefined) {
-                    lineItemRefunds[li.id] = {
-                        hasRefund: false,
-                        refundQuantity: 0,
-                        refundAmount: 0,
-                    };
-                }
-            });
-            order?.refunds?.forEach((refund) => {
-                let totalRefundAmount = 0;
-                refund?.transactions?.forEach((transaction) => {
-                    if (transaction.status === 'success' && transaction.amount) {
-                        totalRefundAmount += parseFloat(transaction.amount);
-                    }
-                });
-                refund?.refund_line_items?.forEach((refundLineItem) => {
-                    if (refundLineItem.line_item_id === undefined)
-                        return;
-                    const target = lineItemRefunds[refundLineItem.line_item_id];
-                    if (!target)
-                        return;
-                    target.hasRefund = true;
-                    target.refundQuantity += refundLineItem?.quantity ?? 0;
-                    const lineItemRefundAmount = parseFloat(String(refundLineItem?.subtotal ?? '0')) + parseFloat(String(refundLineItem?.total_tax ?? '0'));
-                    if (totalRefundAmount >= lineItemRefundAmount) {
-                        target.refundAmount += lineItemRefundAmount;
-                        totalRefundAmount -= lineItemRefundAmount;
-                    }
-                });
-            });
-            return lineItemRefunds;
-        }
-        catch (error) {
-            Logger.error('OrderCostResolutionService.getLineItemsRefundInfo: failed', { error });
-            return {};
-        }
-    },
-    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: OrderCostResolutionService.getGrossSalePrice(order) ?? 0,
-                netSalePrice: OrderCostResolutionService.getNetSalePrice(order) ?? 0,
-                totalProductCost: OrderCostResolutionService.getTotalProductCost(order, lineItemUnitCosts) ?? 0,
-            };
-            const refundInfoByLineItemId = OrderCostResolutionService.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 { CostCalculatorService } from '../cost-calculator-service.js';
+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 = {
+    selectCostHistoryRecordForOrderDate: (costHistory, orderCreatedAt) => {
+        try {
+            if (!costHistory || costHistory.length === 0) {
+                return null;
+            }
+            if (!orderCreatedAt) {
+                return null;
+            }
+            const orderDateTime = DateTime.fromISO(orderCreatedAt).toUTC();
+            if (!orderDateTime.isValid) {
+                return null;
+            }
+            const validCostHistory = costHistory.filter(entry => DateTime.fromISO(entry.effectiveStartDate).isValid);
+            if (validCostHistory.length === 0) {
+                return null;
+            }
+            const sortedCostHistory = [...validCostHistory].sort((a, b) => {
+                const dateA = DateTime.fromISO(a.effectiveStartDate);
+                const dateB = DateTime.fromISO(b.effectiveStartDate);
+                return dateA.toMillis() - dateB.toMillis();
+            });
+            for (const costRecord of sortedCostHistory) {
+                const effectiveStartDate = DateTime.fromISO(costRecord.effectiveStartDate);
+                if (orderDateTime >= effectiveStartDate) {
+                    if (costRecord.effectiveEndDate === null) {
+                        return costRecord;
+                    }
+                    const effectiveEndDate = DateTime.fromISO(costRecord.effectiveEndDate);
+                    if (!effectiveEndDate.isValid) {
+                        continue;
+                    }
+                    if (orderDateTime <= effectiveEndDate) {
+                        return costRecord;
+                    }
+                }
+            }
+            return sortedCostHistory.length > 0 ? sortedCostHistory[0] : null;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.selectCostHistoryRecordForOrderDate: 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;
+        }
+    },
+    resolveOrderLineItemUnitCosts: (lineItems, pixelId, orderCreatedAt, variantRecords, costConfigsByPixelId) => {
+        const result = {};
+        try {
+            const defaultCogsPercent = costConfigsByPixelId[pixelId]?.globalProductOverride?.defaultCogs;
+            let resolvedFromHistoryCount = 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 costHistory = variantRecord.shopifyCostHistory ?? [];
+                    const applicableCostRecord = OrderCostResolutionService.selectCostHistoryRecordForOrderDate(costHistory, orderCreatedAt);
+                    if (applicableCostRecord?.cost !== undefined) {
+                        const cost = applicableCostRecord.cost;
+                        if (cost > 0 && OrderCostResolutionService.isValidCost(cost)) {
+                            result[lineItemId] = cost;
+                            resolvedFromHistoryCount++;
+                            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,
+                resolvedFromHistory: resolvedFromHistoryCount,
+                defaultCogsFallback: defaultCogsFallbackCount,
+                totalResolved: Object.keys(result).length,
+            });
+            return result;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.resolveOrderLineItemUnitCosts: failed', { error, pixelId });
+            return result;
+        }
+    },
+    getOrderCreatedAt: (order, useProcessedAtForNonWebOrders = false) => {
+        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;
+        }
+    },
+    getGrossSalePrice: (order) => {
+        try {
+            let grossSalePrice = 0;
+            order?.line_items?.forEach((lineItem) => {
+                const lineItemPrice = parseFloat(lineItem?.price ?? '0');
+                const quantity = lineItem?.quantity ?? 0;
+                const lineItemSalePrice = lineItemPrice * quantity;
+                if (lineItemSalePrice) {
+                    grossSalePrice += lineItemSalePrice;
+                }
+            });
+            return grossSalePrice;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getGrossSalePrice: failed', { error });
+            return undefined;
+        }
+    },
+    getTotalRefundsFromOrder: (order) => {
+        try {
+            const sumBig = (values) => values.reduce((acc, v) => acc.plus(v), new Big(0));
+            const refundAmounts = order?.refunds?.map((refund) => {
+                const refunds = refund?.transactions?.map((t) => {
+                    if (t.status === 'success' && t.amount) {
+                        const receipt = t?.receipt;
+                        const exchangeRate = receipt?.balance_transaction?.exchange_rate;
+                        if (exchangeRate) {
+                            return new Big(t.amount).times(exchangeRate).div(100);
+                        }
+                        else {
+                            return new Big(t.amount);
+                        }
+                    }
+                    else {
+                        return new Big(0);
+                    }
+                });
+                return sumBig(refunds ?? []);
+            });
+            const refund = sumBig(refundAmounts ?? []).toFixed(2);
+            return parseFloat(refund);
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getTotalRefundsFromOrder: failed', { error });
+            return 0;
+        }
+    },
+    getNetSalePrice: (order) => {
+        try {
+            let netSalePrice;
+            const grossSalePrice = OrderCostResolutionService.getGrossSalePrice(order);
+            const totalRefunds = OrderCostResolutionService.getTotalRefundsFromOrder(order);
+            let totalDiscounts = 0;
+            if (order?.total_discounts_set?.shop_money?.amount) {
+                totalDiscounts = parseFloat(order?.total_discounts_set?.shop_money?.amount ?? '0');
+            }
+            if (grossSalePrice) {
+                netSalePrice = grossSalePrice - (totalRefunds + totalDiscounts);
+            }
+            return netSalePrice;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getNetSalePrice: failed', { error });
+            return undefined;
+        }
+    },
+    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;
+        }
+    },
+    getLineItemsRefundInfo: (order) => {
+        try {
+            const lineItemRefunds = {};
+            order?.line_items?.forEach((li) => {
+                if (li.id !== undefined) {
+                    lineItemRefunds[li.id] = {
+                        hasRefund: false,
+                        refundQuantity: 0,
+                        refundAmount: 0,
+                    };
+                }
+            });
+            order?.refunds?.forEach((refund) => {
+                let totalRefundAmount = 0;
+                refund?.transactions?.forEach((transaction) => {
+                    if (transaction.status === 'success' && transaction.amount) {
+                        totalRefundAmount += parseFloat(transaction.amount);
+                    }
+                });
+                refund?.refund_line_items?.forEach((refundLineItem) => {
+                    if (refundLineItem.line_item_id === undefined)
+                        return;
+                    const target = lineItemRefunds[refundLineItem.line_item_id];
+                    if (!target)
+                        return;
+                    target.hasRefund = true;
+                    target.refundQuantity += refundLineItem?.quantity ?? 0;
+                    const lineItemRefundAmount = parseFloat(String(refundLineItem?.subtotal ?? '0')) + parseFloat(String(refundLineItem?.total_tax ?? '0'));
+                    if (totalRefundAmount >= lineItemRefundAmount) {
+                        target.refundAmount += lineItemRefundAmount;
+                        totalRefundAmount -= lineItemRefundAmount;
+                    }
+                });
+            });
+            return lineItemRefunds;
+        }
+        catch (error) {
+            Logger.error('OrderCostResolutionService.getLineItemsRefundInfo: failed', { error });
+            return {};
+        }
+    },
+    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: OrderCostResolutionService.getGrossSalePrice(order) ?? 0,
+                netSalePrice: OrderCostResolutionService.getNetSalePrice(order) ?? 0,
+                totalProductCost: OrderCostResolutionService.getTotalProductCost(order, lineItemUnitCosts) ?? 0,
+            };
+            const refundInfoByLineItemId = OrderCostResolutionService.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