@adtrackify/at-service-common 4.0.31 → 4.0.33

package/dist/esm/services/cost/cost-calculator-service.js

@@ -1,451 +1,456 @@
-import Big from 'big.js';
-import { DateTime } from 'luxon';
-import { Logger } from '../../helpers/logging-helper.js';
-import { ORDER_COST_ENTRY_TYPE, SHIPPING_METHOD, SHIPPING_RATE_TYPE, WEIGHT_UNIT, } from '@adtrackify/at-tracking-event-types';
-import { normalizeCategory, } from './cost-calculation-types.js';
-import { COST_CATEGORY } from '@adtrackify/at-tracking-event-types';
-import { CostFilterService } from './cost-filter-service.js';
-import { CostCurrencyService } from './cost-currency-service.js';
-const WEIGHT_CONVERSION = {
-    [WEIGHT_UNIT.GRAMS]: 1,
-    [WEIGHT_UNIT.KILOGRAMS]: 1000,
-    [WEIGHT_UNIT.OUNCES]: 28.3495,
-    [WEIGHT_UNIT.POUNDS]: 453.592,
-};
-export const CostCalculatorService = {
-    isDateInRange: (orderDate, effectiveFrom, effectiveTo) => {
-        try {
-            const orderDt = DateTime.fromISO(orderDate);
-            if (!orderDt.isValid)
-                return true;
-            if (effectiveFrom) {
-                const fromDt = DateTime.fromISO(effectiveFrom);
-                if (fromDt.isValid && orderDt < fromDt)
-                    return false;
-            }
-            if (effectiveTo) {
-                const toDt = DateTime.fromISO(effectiveTo);
-                if (toDt.isValid && orderDt > toDt)
-                    return false;
-            }
-            return true;
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.isDateInRange: failed', { error, orderDate, effectiveFrom, effectiveTo });
-            return true;
-        }
-    },
-    findMatchingWeightTierAmount: (tiers, weightGrams, weightUnit) => {
-        try {
-            if (!tiers?.length)
-                return 0;
-            const targetWeight = weightUnit ? weightGrams / (WEIGHT_CONVERSION[weightUnit] ?? 1) : weightGrams;
-            for (const tier of tiers) {
-                const isAboveMin = targetWeight >= tier.weightMin;
-                const isBelowMax = tier.weightMax === null || targetWeight <= tier.weightMax;
-                if (isAboveMin && isBelowMax) {
-                    return tier.flatAmount ?? 0;
-                }
-            }
-            return 0;
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.findMatchingWeightTierAmount: failed', { error, weightGrams, weightUnit, tierCount: tiers?.length });
-            return 0;
-        }
-    },
-    findQuantityTierAmount: (tiers, quantity) => {
-        try {
-            if (!tiers?.length)
-                return 0;
-            for (const tier of tiers) {
-                const isAboveMin = quantity >= tier.quantityMin;
-                const isBelowMax = tier.quantityMax === null || quantity <= tier.quantityMax;
-                if (isAboveMin && isBelowMax) {
-                    return tier.flatAmount ?? 0;
-                }
-            }
-            return 0;
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.findQuantityTierAmount: failed', { error, quantity, tierCount: tiers?.length });
-            return 0;
-        }
-    },
-    calculateHandlingCost: (configs, lineItems, lineItemCosts, orderCurrency, exchangeRatesMap) => {
-        try {
-            const fee = configs.globalProductOverride?.globalHandlingFee ?? 0;
-            if (!fee)
-                return 0;
-            const configCurrency = configs.globalProductOverride?.currency;
-            const convertedFee = configCurrency
-                ? CostCurrencyService.convertAmount(fee, configCurrency, orderCurrency, exchangeRatesMap)
-                : fee;
-            let total = new Big(0);
-            for (const li of lineItems) {
-                total = total.plus(convertedFee);
-                if (lineItemCosts[li.lineItemId]) {
-                    lineItemCosts[li.lineItemId].totalLineItemHandlingCost = new Big(lineItemCosts[li.lineItemId].totalLineItemHandlingCost)
-                        .plus(convertedFee)
-                        .toNumber();
-                }
-            }
-            return total.toNumber();
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateHandlingCost: failed', { error, configs, orderCurrency, lineItemCount: lineItems.length });
-            return 0;
-        }
-    },
-    calculateGatewayCost: (configs, orderGateways, totalPrice, orderCreatedAt, orderCurrency, exchangeRatesMap) => {
-        try {
-            const gatewayConfig = configs.gateway;
-            if (!gatewayConfig?.entries?.length)
-                return 0;
-            const normalizedOrderGateways = orderGateways.map((g) => g.toLowerCase());
-            const matchingEntry = gatewayConfig.entries.find((entry) => {
-                const gatewayMatches = normalizedOrderGateways.includes(entry.gatewayName.toLowerCase());
-                const dateValid = CostCalculatorService.isDateInRange(orderCreatedAt, entry.effectiveFrom, entry.effectiveTo);
-                return gatewayMatches && dateValid;
-            });
-            if (!matchingEntry)
-                return 0;
-            const rawFlatAmount = matchingEntry.flatAmount ?? 0;
-            const convertedFlatAmount = CostCurrencyService.convertAmount(rawFlatAmount, matchingEntry.currency, orderCurrency, exchangeRatesMap);
-            const flatAmount = new Big(convertedFlatAmount);
-            const percentAmount = new Big(totalPrice).times(matchingEntry.percentRate ?? 0).div(100);
-            return flatAmount.plus(percentAmount).toNumber();
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateGatewayCost: failed', { error, configs, orderCurrency, orderGateways, totalPrice, orderCreatedAt });
-            return 0;
-        }
-    },
-    findMatchingShippingProfile: (profiles, shipCountryCode, orderCreatedAt, orderFilterContext) => {
-        try {
-            if (!profiles?.length)
-                return null;
-            let defaultProfile = null;
-            for (const profile of profiles) {
-                if (!CostCalculatorService.isDateInRange(orderCreatedAt, profile.effectiveFrom, profile.effectiveTo)) {
-                    continue;
-                }
-                if (profile.filters && orderFilterContext && !CostFilterService.matchesFilters(profile.filters, orderFilterContext, null)) {
-                    continue;
-                }
-                if (profile.isDefault) {
-                    defaultProfile = profile;
-                }
-                if (shipCountryCode && profile.countries?.length) {
-                    const normalizedCountry = shipCountryCode.toLowerCase();
-                    const countryMatches = profile.countries.some((c) => c.toLowerCase() === normalizedCountry);
-                    if (countryMatches) {
-                        return profile;
-                    }
-                }
-            }
-            return defaultProfile;
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.findMatchingShippingProfile: failed', { error, shipCountryCode });
-            return null;
-        }
-    },
-    calculateShippingCost: (configs, shopifyShippingAmount, shipCountryCode, totalWeightGrams, orderCreatedAt, orderCurrency, exchangeRatesMap, orderFilterContext) => {
-        try {
-            const shippingConfig = configs.shipping;
-            if (!shippingConfig)
-                return 0;
-            switch (shippingConfig.method) {
-                case SHIPPING_METHOD.SHOPIFY_CHARGES:
-                    return shopifyShippingAmount;
-                case SHIPPING_METHOD.FIXED_RATE: {
-                    const fixedAmount = shippingConfig.fixedRateAmount ?? 0;
-                    return CostCurrencyService.convertAmount(fixedAmount, shippingConfig.currency, orderCurrency, exchangeRatesMap);
-                }
-                case SHIPPING_METHOD.SHIPPING_PROFILES: {
-                    const profile = CostCalculatorService.findMatchingShippingProfile(shippingConfig.profiles, shipCountryCode, orderCreatedAt, orderFilterContext);
-                    if (!profile)
-                        return 0;
-                    if (profile.rateType === SHIPPING_RATE_TYPE.FLAT) {
-                        const flatAmount = profile.flatAmount ?? 0;
-                        return CostCurrencyService.convertAmount(flatAmount, profile.currency, orderCurrency, exchangeRatesMap);
-                    }
-                    if (profile.rateType === SHIPPING_RATE_TYPE.WEIGHT_TIERED) {
-                        const tierAmount = CostCalculatorService.findMatchingWeightTierAmount(profile.weightTiers, totalWeightGrams, profile.weightUnit);
-                        return CostCurrencyService.convertAmount(tierAmount, profile.currency, orderCurrency, exchangeRatesMap);
-                    }
-                    return 0;
-                }
-                default:
-                    return 0;
-            }
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateShippingCost: failed', { error, configs, orderCurrency, shipCountryCode, totalWeightGrams });
-            return 0;
-        }
-    },
-    calculateOtherCostEntry: (entry, context, lineItemCosts, orderCurrency, exchangeRatesMap) => {
-        const defaultResult = { orderLevel: 0, lineItemLevel: 0 };
-        try {
-            let orderLevelCost = new Big(0);
-            let lineItemLevelCost = new Big(0);
-            const { orderFilterContext, lineItems, totalWeight, totalQuantity, hasRefund, totalProductCost, totalShipping, totalPrice, grossSalePrice, netSalePrice } = context;
-            if (!CostFilterService.matchesFilters(entry.filters, orderFilterContext, null, lineItems.map(li => li.filterContext))) {
-                return defaultResult;
-            }
-            const convertFlat = (amount) => CostCurrencyService.convertAmount(amount, entry.currency, orderCurrency, exchangeRatesMap);
-            switch (entry.type) {
-                case ORDER_COST_ENTRY_TYPE.PER_ORDER:
-                    orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0));
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM:
-                    for (const li of lineItems) {
-                        if (CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
-                            const amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.quantity);
-                            lineItemLevelCost = lineItemLevelCost.plus(amount);
-                            if (lineItemCosts[li.lineItemId]) {
-                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
-                                    .plus(amount)
-                                    .toNumber();
-                            }
-                        }
-                    }
-                    break;
-                case ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT: {
-                    if (entry.weightIntervals?.length) {
-                        const tierAmount = CostCalculatorService.findMatchingWeightTierAmount(entry.weightIntervals, totalWeight, entry.weightUnit);
-                        orderLevelCost = new Big(convertFlat(tierAmount));
-                    }
-                    else {
-                        const weightInUnit = entry.weightUnit
-                            ? totalWeight / (WEIGHT_CONVERSION[entry.weightUnit] ?? 1)
-                            : totalWeight;
-                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0)).times(weightInUnit);
-                    }
-                    break;
-                }
-                case ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY:
-                    for (const li of lineItems) {
-                        if (CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
-                            let amount;
-                            if (entry.quantityIntervals?.length) {
-                                const tierAmount = CostCalculatorService.findQuantityTierAmount(entry.quantityIntervals, li.quantity);
-                                amount = new Big(convertFlat(tierAmount));
-                            }
-                            else {
-                                amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.quantity);
-                            }
-                            lineItemLevelCost = lineItemLevelCost.plus(amount);
-                            if (lineItemCosts[li.lineItemId]) {
-                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
-                                    .plus(amount)
-                                    .toNumber();
-                            }
-                        }
-                    }
-                    break;
-                case ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY:
-                    if (entry.quantityIntervals?.length) {
-                        const tierAmount = CostCalculatorService.findQuantityTierAmount(entry.quantityIntervals, totalQuantity);
-                        orderLevelCost = new Big(convertFlat(tierAmount));
-                    }
-                    else {
-                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0)).times(totalQuantity);
-                    }
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER:
-                    if (hasRefund) {
-                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0));
-                    }
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM:
-                    for (const li of lineItems) {
-                        if (li.refundedQuantity > 0 && CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
-                            const amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.refundedQuantity);
-                            lineItemLevelCost = lineItemLevelCost.plus(amount);
-                            if (lineItemCosts[li.lineItemId]) {
-                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
-                                    .plus(amount)
-                                    .toNumber();
-                            }
-                        }
-                    }
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PCT_COGS:
-                    orderLevelCost = new Big(totalProductCost).times(entry.percentRate ?? 0).div(100);
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PCT_SHIPPING:
-                    orderLevelCost = new Big(totalShipping).times(entry.percentRate ?? 0).div(100);
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES:
-                    orderLevelCost = new Big(totalPrice).times(entry.percentRate ?? 0).div(100);
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES:
-                    orderLevelCost = new Big(grossSalePrice).times(entry.percentRate ?? 0).div(100);
-                    break;
-                case ORDER_COST_ENTRY_TYPE.PCT_NET_SALES:
-                    orderLevelCost = new Big(netSalePrice).times(entry.percentRate ?? 0).div(100);
-                    break;
-                default:
-                    break;
-            }
-            return { orderLevel: orderLevelCost.toNumber(), lineItemLevel: lineItemLevelCost.toNumber() };
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateOtherCostEntry: failed', { error, entry, orderCurrency });
-            return defaultResult;
-        }
-    },
-    calculateOtherCost: (configs, context, lineItemCosts, orderCurrency, exchangeRatesMap) => {
-        const defaultCategoryCosts = {
-            totalOtherCogs: 0,
-            otherFulfillmentCost: 0,
-            otherTransactionCost: 0,
-            marketingCost: 0,
-            agencyFeesCost: 0,
-            opexCost: 0,
-            totalOtherCost: 0,
-        };
-        const defaultResult = { orderLevel: 0, lineItemLevel: 0, total: 0, categoryCosts: defaultCategoryCosts };
-        try {
-            const orderConfig = configs.order;
-            if (!orderConfig?.entries?.length)
-                return defaultResult;
-            let orderLevelTotal = new Big(0);
-            let lineItemLevelTotal = new Big(0);
-            const categoryCosts = { ...defaultCategoryCosts };
-            for (const entry of orderConfig.entries) {
-                if (!CostCalculatorService.isDateInRange(context.orderCreatedAt, entry.effectiveFrom, entry.effectiveTo)) {
-                    continue;
-                }
-                try {
-                    const entryCost = CostCalculatorService.calculateOtherCostEntry(entry, context, lineItemCosts, orderCurrency, exchangeRatesMap);
-                    const entryTotal = entryCost.orderLevel + entryCost.lineItemLevel;
-                    orderLevelTotal = orderLevelTotal.plus(entryCost.orderLevel);
-                    lineItemLevelTotal = lineItemLevelTotal.plus(entryCost.lineItemLevel);
-                    const category = normalizeCategory(entry.category);
-                    switch (category) {
-                        case COST_CATEGORY.COGS:
-                            categoryCosts.totalOtherCogs += entryTotal;
-                            break;
-                        case COST_CATEGORY.FULFILLMENT:
-                            categoryCosts.otherFulfillmentCost += entryTotal;
-                            break;
-                        case COST_CATEGORY.TRANSACTION:
-                            categoryCosts.otherTransactionCost += entryTotal;
-                            break;
-                        case COST_CATEGORY.MARKETING:
-                            categoryCosts.marketingCost += entryTotal;
-                            break;
-                        case COST_CATEGORY.AGENCY_FEES:
-                            categoryCosts.agencyFeesCost += entryTotal;
-                            break;
-                        case COST_CATEGORY.OPEX:
-                            categoryCosts.opexCost += entryTotal;
-                            break;
-                        case COST_CATEGORY.OTHER:
-                        default:
-                            categoryCosts.totalOtherCost += entryTotal;
-                            break;
-                    }
-                }
-                catch (entryError) {
-                    Logger.warn('CostCalculatorService.calculateOtherCost: entry failed', {
-                        error: entryError,
-                        entryId: entry.id,
-                        category: entry.category,
-                    });
-                }
-            }
-            return {
-                orderLevel: orderLevelTotal.toNumber(),
-                lineItemLevel: lineItemLevelTotal.toNumber(),
-                total: orderLevelTotal.plus(lineItemLevelTotal).toNumber(),
-                categoryCosts,
-            };
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateOtherCost: failed', { error, configs, orderCurrency });
-            return defaultResult;
-        }
-    },
-    calculateLineItemHandlingCosts: (lineItems) => {
-        try {
-            const result = {};
-            for (const li of lineItems) {
-                const handlingFee = li.variantHandlingFee ?? 0;
-                result[li.lineItemId] = new Big(handlingFee).times(li.quantity).toNumber();
-            }
-            return result;
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateLineItemHandlingCosts: failed', { error, lineItemCount: lineItems.length });
-            return {};
-        }
-    },
-    calculateOrderCosts: (configs, context, orderCurrency, exchangeRatesMap) => {
-        const defaultCategoryCosts = {
-            totalOtherCogs: 0,
-            otherFulfillmentCost: 0,
-            otherTransactionCost: 0,
-            marketingCost: 0,
-            agencyFeesCost: 0,
-            opexCost: 0,
-            totalOtherCost: 0,
-        };
-        const defaultResult = {
-            orderLevelHandlingCost: 0,
-            lineItemLevelHandlingCost: 0,
-            totalHandlingCost: 0,
-            orderLevelOtherCost: 0,
-            lineItemLevelOtherCost: 0,
-            totalOtherCost: 0,
-            totalGatewayCost: 0,
-            totalShippingCost: 0,
-            lineItemCosts: {},
-            categoryCosts: defaultCategoryCosts,
-        };
-        if (!configs) {
-            return defaultResult;
-        }
-        try {
-            const lineItemCosts = {};
-            for (const li of context.lineItems) {
-                lineItemCosts[li.lineItemId] = { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 };
-            }
-            const lineItemHandlingCosts = CostCalculatorService.calculateLineItemHandlingCosts(context.lineItems);
-            for (const [lineItemId, handlingCost] of Object.entries(lineItemHandlingCosts)) {
-                if (lineItemCosts[lineItemId]) {
-                    lineItemCosts[lineItemId].totalLineItemHandlingCost = handlingCost;
-                }
-            }
-            CostCalculatorService.calculateHandlingCost(configs, context.lineItems, lineItemCosts, orderCurrency, exchangeRatesMap);
-            const lineItemLevelHandlingCost = Object.values(lineItemCosts).reduce((sum, li) => new Big(sum).plus(li.totalLineItemHandlingCost).toNumber(), 0);
-            const orderLevelHandlingCost = 0;
-            const totalHandlingCost = orderLevelHandlingCost + lineItemLevelHandlingCost;
-            const totalGatewayCost = CostCalculatorService.calculateGatewayCost(configs, context.orderFilterContext.paymentGateways, context.totalPrice, context.orderCreatedAt, orderCurrency, exchangeRatesMap);
-            const shopifyShippingAmount = context.totalShipping;
-            const totalShippingCost = CostCalculatorService.calculateShippingCost(configs, shopifyShippingAmount, context.orderFilterContext.shipCountryCode, context.totalWeight, context.orderCreatedAt, orderCurrency, exchangeRatesMap, context.orderFilterContext);
-            const otherCostResult = CostCalculatorService.calculateOtherCost(configs, context, lineItemCosts, orderCurrency, exchangeRatesMap);
-            return {
-                orderLevelHandlingCost,
-                lineItemLevelHandlingCost,
-                totalHandlingCost,
-                orderLevelOtherCost: otherCostResult.orderLevel,
-                lineItemLevelOtherCost: otherCostResult.lineItemLevel,
-                totalOtherCost: otherCostResult.categoryCosts.totalOtherCost,
-                totalGatewayCost,
-                totalShippingCost,
-                lineItemCosts,
-                categoryCosts: otherCostResult.categoryCosts,
-            };
-        }
-        catch (error) {
-            Logger.error('CostCalculatorService.calculateOrderCosts: failed', { error, configs, orderCurrency });
-            return defaultResult;
-        }
-    },
-};
+import Big from 'big.js';
+import { DateTime } from 'luxon';
+import { Logger } from '../../helpers/logging-helper.js';
+import { ORDER_COST_ENTRY_TYPE, SHIPPING_METHOD, SHIPPING_RATE_TYPE, WEIGHT_UNIT, } from '@adtrackify/at-tracking-event-types';
+import { normalizeCategory, } from './cost-calculation-types.js';
+import { COST_CATEGORY } from '@adtrackify/at-tracking-event-types';
+import { CostFilterService } from './cost-filter-service.js';
+import { CostCurrencyService } from './cost-currency-service.js';
+const WEIGHT_CONVERSION = {
+    [WEIGHT_UNIT.GRAMS]: 1,
+    [WEIGHT_UNIT.KILOGRAMS]: 1000,
+    [WEIGHT_UNIT.OUNCES]: 28.3495,
+    [WEIGHT_UNIT.POUNDS]: 453.592,
+};
+export const CostCalculatorService = {
+    isDateInRange: (orderDate, effectiveFrom, effectiveTo) => {
+        try {
+            const orderDt = DateTime.fromISO(orderDate);
+            if (!orderDt.isValid)
+                return true;
+            if (effectiveFrom) {
+                const fromDt = DateTime.fromISO(effectiveFrom);
+                if (fromDt.isValid && orderDt < fromDt)
+                    return false;
+            }
+            if (effectiveTo) {
+                const toDt = DateTime.fromISO(effectiveTo);
+                if (toDt.isValid && orderDt > toDt)
+                    return false;
+            }
+            return true;
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.isDateInRange: failed', { error, orderDate, effectiveFrom, effectiveTo });
+            return true;
+        }
+    },
+    findMatchingWeightTierAmount: (tiers, weightGrams, weightUnit) => {
+        try {
+            if (!tiers?.length)
+                return 0;
+            const targetWeight = weightUnit ? weightGrams / (WEIGHT_CONVERSION[weightUnit] ?? 1) : weightGrams;
+            for (const tier of tiers) {
+                const isAboveMin = targetWeight >= tier.weightMin;
+                const isBelowMax = tier.weightMax === null || targetWeight <= tier.weightMax;
+                if (isAboveMin && isBelowMax) {
+                    return tier.flatAmount ?? 0;
+                }
+            }
+            return 0;
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.findMatchingWeightTierAmount: failed', { error, weightGrams, weightUnit, tierCount: tiers?.length });
+            return 0;
+        }
+    },
+    findQuantityTierAmount: (tiers, quantity) => {
+        try {
+            if (!tiers?.length)
+                return 0;
+            for (const tier of tiers) {
+                const isAboveMin = quantity >= tier.quantityMin;
+                const isBelowMax = tier.quantityMax === null || quantity <= tier.quantityMax;
+                if (isAboveMin && isBelowMax) {
+                    return tier.flatAmount ?? 0;
+                }
+            }
+            return 0;
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.findQuantityTierAmount: failed', { error, quantity, tierCount: tiers?.length });
+            return 0;
+        }
+    },
+    calculateHandlingCost: (configs, lineItems, lineItemCosts, orderCurrency, exchangeRatesMap) => {
+        try {
+            const fee = configs.globalProductOverride?.globalHandlingFee ?? 0;
+            if (!fee)
+                return 0;
+            const configCurrency = configs.globalProductOverride?.currency;
+            const convertedFee = configCurrency
+                ? CostCurrencyService.convertAmount(fee, configCurrency, orderCurrency, exchangeRatesMap)
+                : fee;
+            let total = new Big(0);
+            for (const li of lineItems) {
+                if (li.variantHandlingFee !== undefined) {
+                    continue;
+                }
+                total = total.plus(convertedFee);
+                if (lineItemCosts[li.lineItemId]) {
+                    lineItemCosts[li.lineItemId].totalLineItemHandlingCost = new Big(lineItemCosts[li.lineItemId].totalLineItemHandlingCost)
+                        .plus(convertedFee)
+                        .toNumber();
+                }
+            }
+            return total.toNumber();
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateHandlingCost: failed', { error, configs, orderCurrency, lineItemCount: lineItems.length });
+            return 0;
+        }
+    },
+    calculateGatewayCost: (configs, orderGateways, totalPrice, orderCreatedAt, orderCurrency, exchangeRatesMap) => {
+        try {
+            const gatewayConfig = configs.gateway;
+            if (!gatewayConfig?.entries?.length)
+                return 0;
+            const normalizedOrderGateways = orderGateways.map((g) => g.toLowerCase());
+            const matchingEntry = gatewayConfig.entries.find((entry) => {
+                const gatewayMatches = normalizedOrderGateways.includes(entry.gatewayName.toLowerCase());
+                const dateValid = CostCalculatorService.isDateInRange(orderCreatedAt, entry.effectiveFrom, entry.effectiveTo);
+                return gatewayMatches && dateValid;
+            });
+            if (!matchingEntry)
+                return 0;
+            const rawFlatAmount = matchingEntry.flatAmount ?? 0;
+            const convertedFlatAmount = CostCurrencyService.convertAmount(rawFlatAmount, matchingEntry.currency, orderCurrency, exchangeRatesMap);
+            const flatAmount = new Big(convertedFlatAmount);
+            const percentAmount = new Big(totalPrice).times(matchingEntry.percentRate ?? 0).div(100);
+            return flatAmount.plus(percentAmount).toNumber();
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateGatewayCost: failed', { error, configs, orderCurrency, orderGateways, totalPrice, orderCreatedAt });
+            return 0;
+        }
+    },
+    findMatchingShippingProfile: (profiles, shipCountryCode, orderCreatedAt, orderFilterContext) => {
+        try {
+            if (!profiles?.length)
+                return null;
+            let defaultProfile = null;
+            for (const profile of profiles) {
+                if (!CostCalculatorService.isDateInRange(orderCreatedAt, profile.effectiveFrom, profile.effectiveTo)) {
+                    continue;
+                }
+                if (profile.filters && orderFilterContext && !CostFilterService.matchesFilters(profile.filters, orderFilterContext, null)) {
+                    continue;
+                }
+                if (profile.isDefault) {
+                    defaultProfile = profile;
+                }
+                if (shipCountryCode && profile.countries?.length) {
+                    const normalizedCountry = shipCountryCode.toLowerCase();
+                    const countryMatches = profile.countries.some((c) => c.toLowerCase() === normalizedCountry);
+                    if (countryMatches) {
+                        return profile;
+                    }
+                }
+            }
+            return defaultProfile;
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.findMatchingShippingProfile: failed', { error, shipCountryCode });
+            return null;
+        }
+    },
+    calculateShippingCost: (configs, shopifyShippingAmount, shipCountryCode, totalWeightGrams, orderCreatedAt, orderCurrency, exchangeRatesMap, orderFilterContext) => {
+        try {
+            const shippingConfig = configs.shipping;
+            if (!shippingConfig)
+                return 0;
+            switch (shippingConfig.method) {
+                case SHIPPING_METHOD.SHOPIFY_CHARGES:
+                    return shopifyShippingAmount;
+                case SHIPPING_METHOD.FIXED_RATE: {
+                    const fixedAmount = shippingConfig.fixedRateAmount ?? 0;
+                    return CostCurrencyService.convertAmount(fixedAmount, shippingConfig.currency, orderCurrency, exchangeRatesMap);
+                }
+                case SHIPPING_METHOD.SHIPPING_PROFILES: {
+                    const profile = CostCalculatorService.findMatchingShippingProfile(shippingConfig.profiles, shipCountryCode, orderCreatedAt, orderFilterContext);
+                    if (!profile)
+                        return 0;
+                    if (profile.rateType === SHIPPING_RATE_TYPE.FLAT) {
+                        const flatAmount = profile.flatAmount ?? 0;
+                        return CostCurrencyService.convertAmount(flatAmount, profile.currency, orderCurrency, exchangeRatesMap);
+                    }
+                    if (profile.rateType === SHIPPING_RATE_TYPE.WEIGHT_TIERED) {
+                        const tierAmount = CostCalculatorService.findMatchingWeightTierAmount(profile.weightTiers, totalWeightGrams, profile.weightUnit);
+                        return CostCurrencyService.convertAmount(tierAmount, profile.currency, orderCurrency, exchangeRatesMap);
+                    }
+                    return 0;
+                }
+                default:
+                    return 0;
+            }
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateShippingCost: failed', { error, configs, orderCurrency, shipCountryCode, totalWeightGrams });
+            return 0;
+        }
+    },
+    calculateOtherCostEntry: (entry, context, lineItemCosts, orderCurrency, exchangeRatesMap) => {
+        const defaultResult = { orderLevel: 0, lineItemLevel: 0 };
+        try {
+            let orderLevelCost = new Big(0);
+            let lineItemLevelCost = new Big(0);
+            const { orderFilterContext, lineItems, totalWeight, totalQuantity, hasRefund, totalProductCost, totalShipping, totalPrice, grossSalePrice, netSalePrice } = context;
+            if (!CostFilterService.matchesFilters(entry.filters, orderFilterContext, null, lineItems.map(li => li.filterContext))) {
+                return defaultResult;
+            }
+            const convertFlat = (amount) => CostCurrencyService.convertAmount(amount, entry.currency, orderCurrency, exchangeRatesMap);
+            switch (entry.type) {
+                case ORDER_COST_ENTRY_TYPE.PER_ORDER:
+                    orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0));
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PER_LINE_ITEM:
+                    for (const li of lineItems) {
+                        if (CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
+                            const amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.quantity);
+                            lineItemLevelCost = lineItemLevelCost.plus(amount);
+                            if (lineItemCosts[li.lineItemId]) {
+                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
+                                    .plus(amount)
+                                    .toNumber();
+                            }
+                        }
+                    }
+                    break;
+                case ORDER_COST_ENTRY_TYPE.BY_ORDER_WEIGHT: {
+                    if (entry.weightIntervals?.length) {
+                        const tierAmount = CostCalculatorService.findMatchingWeightTierAmount(entry.weightIntervals, totalWeight, entry.weightUnit);
+                        orderLevelCost = new Big(convertFlat(tierAmount));
+                    }
+                    else {
+                        const weightInUnit = entry.weightUnit
+                            ? totalWeight / (WEIGHT_CONVERSION[entry.weightUnit] ?? 1)
+                            : totalWeight;
+                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0)).times(weightInUnit);
+                    }
+                    break;
+                }
+                case ORDER_COST_ENTRY_TYPE.BY_LINE_ITEM_QUANTITY:
+                    for (const li of lineItems) {
+                        if (CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
+                            let amount;
+                            if (entry.quantityIntervals?.length) {
+                                const tierAmount = CostCalculatorService.findQuantityTierAmount(entry.quantityIntervals, li.quantity);
+                                amount = new Big(convertFlat(tierAmount));
+                            }
+                            else {
+                                amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.quantity);
+                            }
+                            lineItemLevelCost = lineItemLevelCost.plus(amount);
+                            if (lineItemCosts[li.lineItemId]) {
+                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
+                                    .plus(amount)
+                                    .toNumber();
+                            }
+                        }
+                    }
+                    break;
+                case ORDER_COST_ENTRY_TYPE.BY_ORDER_QUANTITY:
+                    if (entry.quantityIntervals?.length) {
+                        const tierAmount = CostCalculatorService.findQuantityTierAmount(entry.quantityIntervals, totalQuantity);
+                        orderLevelCost = new Big(convertFlat(tierAmount));
+                    }
+                    else {
+                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0)).times(totalQuantity);
+                    }
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PER_REFUND_ORDER:
+                    if (hasRefund) {
+                        orderLevelCost = new Big(convertFlat(entry.flatAmount ?? 0));
+                    }
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PER_REFUND_LINE_ITEM:
+                    for (const li of lineItems) {
+                        if (li.refundedQuantity > 0 && CostFilterService.matchesFilters(entry.filters, orderFilterContext, li.filterContext)) {
+                            const amount = new Big(convertFlat(entry.flatAmount ?? 0)).times(li.refundedQuantity);
+                            lineItemLevelCost = lineItemLevelCost.plus(amount);
+                            if (lineItemCosts[li.lineItemId]) {
+                                lineItemCosts[li.lineItemId].totalLineItemOtherCost = new Big(lineItemCosts[li.lineItemId].totalLineItemOtherCost)
+                                    .plus(amount)
+                                    .toNumber();
+                            }
+                        }
+                    }
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PCT_COGS:
+                    orderLevelCost = new Big(totalProductCost).times(entry.percentRate ?? 0).div(100);
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PCT_SHIPPING:
+                    orderLevelCost = new Big(totalShipping).times(entry.percentRate ?? 0).div(100);
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PCT_TOTAL_SALES:
+                    orderLevelCost = new Big(totalPrice).times(entry.percentRate ?? 0).div(100);
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PCT_GROSS_SALES:
+                    orderLevelCost = new Big(grossSalePrice).times(entry.percentRate ?? 0).div(100);
+                    break;
+                case ORDER_COST_ENTRY_TYPE.PCT_NET_SALES:
+                    orderLevelCost = new Big(netSalePrice).times(entry.percentRate ?? 0).div(100);
+                    break;
+                default:
+                    break;
+            }
+            return { orderLevel: orderLevelCost.toNumber(), lineItemLevel: lineItemLevelCost.toNumber() };
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateOtherCostEntry: failed', { error, entry, orderCurrency });
+            return defaultResult;
+        }
+    },
+    calculateOtherCost: (configs, context, lineItemCosts, orderCurrency, exchangeRatesMap) => {
+        const defaultCategoryCosts = {
+            totalOtherCogs: 0,
+            otherFulfillmentCost: 0,
+            otherTransactionCost: 0,
+            marketingCost: 0,
+            agencyFeesCost: 0,
+            opexCost: 0,
+            totalOtherCost: 0,
+        };
+        const defaultResult = { orderLevel: 0, lineItemLevel: 0, total: 0, categoryCosts: defaultCategoryCosts };
+        try {
+            const orderConfig = configs.order;
+            if (!orderConfig?.entries?.length)
+                return defaultResult;
+            let orderLevelTotal = new Big(0);
+            let lineItemLevelTotal = new Big(0);
+            const categoryCosts = { ...defaultCategoryCosts };
+            for (const entry of orderConfig.entries) {
+                if (!CostCalculatorService.isDateInRange(context.orderCreatedAt, entry.effectiveFrom, entry.effectiveTo)) {
+                    continue;
+                }
+                try {
+                    const entryCost = CostCalculatorService.calculateOtherCostEntry(entry, context, lineItemCosts, orderCurrency, exchangeRatesMap);
+                    const entryTotal = entryCost.orderLevel + entryCost.lineItemLevel;
+                    orderLevelTotal = orderLevelTotal.plus(entryCost.orderLevel);
+                    lineItemLevelTotal = lineItemLevelTotal.plus(entryCost.lineItemLevel);
+                    const category = normalizeCategory(entry.category);
+                    switch (category) {
+                        case COST_CATEGORY.COGS:
+                            categoryCosts.totalOtherCogs += entryTotal;
+                            break;
+                        case COST_CATEGORY.FULFILLMENT:
+                            categoryCosts.otherFulfillmentCost += entryTotal;
+                            break;
+                        case COST_CATEGORY.TRANSACTION:
+                            categoryCosts.otherTransactionCost += entryTotal;
+                            break;
+                        case COST_CATEGORY.MARKETING:
+                            categoryCosts.marketingCost += entryTotal;
+                            break;
+                        case COST_CATEGORY.AGENCY_FEES:
+                            categoryCosts.agencyFeesCost += entryTotal;
+                            break;
+                        case COST_CATEGORY.OPEX:
+                            categoryCosts.opexCost += entryTotal;
+                            break;
+                        case COST_CATEGORY.OTHER:
+                        default:
+                            categoryCosts.totalOtherCost += entryTotal;
+                            break;
+                    }
+                }
+                catch (entryError) {
+                    Logger.warn('CostCalculatorService.calculateOtherCost: entry failed', {
+                        error: entryError,
+                        entryId: entry.id,
+                        category: entry.category,
+                    });
+                }
+            }
+            return {
+                orderLevel: orderLevelTotal.toNumber(),
+                lineItemLevel: lineItemLevelTotal.toNumber(),
+                total: orderLevelTotal.plus(lineItemLevelTotal).toNumber(),
+                categoryCosts,
+            };
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateOtherCost: failed', { error, configs, orderCurrency });
+            return defaultResult;
+        }
+    },
+    calculateLineItemHandlingCosts: (lineItems) => {
+        try {
+            const result = {};
+            for (const li of lineItems) {
+                if (li.variantHandlingFee === undefined) {
+                    continue;
+                }
+                result[li.lineItemId] = new Big(li.variantHandlingFee).times(li.quantity).toNumber();
+            }
+            return result;
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateLineItemHandlingCosts: failed', { error, lineItemCount: lineItems.length });
+            return {};
+        }
+    },
+    calculateOrderCosts: (configs, context, orderCurrency, exchangeRatesMap) => {
+        const defaultCategoryCosts = {
+            totalOtherCogs: 0,
+            otherFulfillmentCost: 0,
+            otherTransactionCost: 0,
+            marketingCost: 0,
+            agencyFeesCost: 0,
+            opexCost: 0,
+            totalOtherCost: 0,
+        };
+        const defaultResult = {
+            orderLevelHandlingCost: 0,
+            lineItemLevelHandlingCost: 0,
+            totalHandlingCost: 0,
+            orderLevelOtherCost: 0,
+            lineItemLevelOtherCost: 0,
+            totalOtherCost: 0,
+            totalGatewayCost: 0,
+            totalShippingCost: 0,
+            lineItemCosts: {},
+            categoryCosts: defaultCategoryCosts,
+        };
+        if (!configs) {
+            return defaultResult;
+        }
+        try {
+            const lineItemCosts = {};
+            for (const li of context.lineItems) {
+                lineItemCosts[li.lineItemId] = { totalLineItemHandlingCost: 0, totalLineItemOtherCost: 0 };
+            }
+            const lineItemHandlingCosts = CostCalculatorService.calculateLineItemHandlingCosts(context.lineItems);
+            for (const [lineItemId, handlingCost] of Object.entries(lineItemHandlingCosts)) {
+                if (lineItemCosts[lineItemId]) {
+                    lineItemCosts[lineItemId].totalLineItemHandlingCost = handlingCost;
+                }
+            }
+            CostCalculatorService.calculateHandlingCost(configs, context.lineItems, lineItemCosts, orderCurrency, exchangeRatesMap);
+            const lineItemLevelHandlingCost = Object.values(lineItemCosts).reduce((sum, li) => new Big(sum).plus(li.totalLineItemHandlingCost).toNumber(), 0);
+            const orderLevelHandlingCost = 0;
+            const totalHandlingCost = orderLevelHandlingCost + lineItemLevelHandlingCost;
+            const totalGatewayCost = CostCalculatorService.calculateGatewayCost(configs, context.orderFilterContext.paymentGateways, context.totalPrice, context.orderCreatedAt, orderCurrency, exchangeRatesMap);
+            const shopifyShippingAmount = context.totalShipping;
+            const totalShippingCost = CostCalculatorService.calculateShippingCost(configs, shopifyShippingAmount, context.orderFilterContext.shipCountryCode, context.totalWeight, context.orderCreatedAt, orderCurrency, exchangeRatesMap, context.orderFilterContext);
+            const otherCostResult = CostCalculatorService.calculateOtherCost(configs, context, lineItemCosts, orderCurrency, exchangeRatesMap);
+            return {
+                orderLevelHandlingCost,
+                lineItemLevelHandlingCost,
+                totalHandlingCost,
+                orderLevelOtherCost: otherCostResult.orderLevel,
+                lineItemLevelOtherCost: otherCostResult.lineItemLevel,
+                totalOtherCost: otherCostResult.categoryCosts.totalOtherCost,
+                totalGatewayCost,
+                totalShippingCost,
+                lineItemCosts,
+                categoryCosts: otherCostResult.categoryCosts,
+            };
+        }
+        catch (error) {
+            Logger.error('CostCalculatorService.calculateOrderCosts: failed', { error, configs, orderCurrency });
+            return defaultResult;
+        }
+    },
+};
 //# sourceMappingURL=cost-calculator-service.js.map