@medusajs/promotion 3.0.0-snapshot-20250410112222 → 3.0.0-snapshot-20251104011621

package/dist/services/promotion-module.js

@@ -18,15 +18,17 @@ const _models_1 = require("../models");
 const _types_1 = require("../types");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
+const build_promotion_rule_query_filter_from_context_1 = require("../utils/compute-actions/build-promotion-rule-query-filter-from-context");
 class PromotionModuleService extends (0, utils_1.MedusaService)({
     Promotion: _models_1.Promotion,
     ApplicationMethod: _models_1.ApplicationMethod,
     Campaign: _models_1.Campaign,
     CampaignBudget: _models_1.CampaignBudget,
+    CampaignBudgetUsage: _models_1.CampaignBudgetUsage,
     PromotionRule: _models_1.PromotionRule,
     PromotionRuleValue: _models_1.PromotionRuleValue,
 }) {
-    constructor({ baseRepository, promotionService, applicationMethodService, promotionRuleService, promotionRuleValueService, campaignService, campaignBudgetService, }, moduleDeclaration) {
+    constructor({ baseRepository, promotionService, applicationMethodService, promotionRuleService, promotionRuleValueService, campaignService, campaignBudgetService, campaignBudgetUsageService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
@@ -37,44 +39,102 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         this.promotionRuleValueService_ = promotionRuleValueService;
         this.campaignService_ = campaignService;
         this.campaignBudgetService_ = campaignBudgetService;
+        this.campaignBudgetUsageService_ = campaignBudgetUsageService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
-    listActivePromotions(filters, config, sharedContext) {
+    async listActivePromotions(filters, config, sharedContext) {
+        const activePromotions = await this.listActivePromotions_(filters, config, sharedContext);
+        return this.baseRepository_.serialize(activePromotions);
+    }
+    async listActivePromotions_(filters, config, sharedContext) {
+        // Ensure we share the same now date across all filters
+        const now = new Date();
         const activeFilters = {
+            status: utils_1.PromotionStatus.ACTIVE,
             $or: [
                 {
-                    status: utils_1.PromotionStatus.ACTIVE,
                     campaign_id: null,
                     ...filters,
                 },
                 {
-                    status: utils_1.PromotionStatus.ACTIVE,
                     ...filters,
                     campaign: {
                         ...filters?.campaign,
                         $and: [
                             {
-                                $or: [{ starts_at: null }, { starts_at: { $lte: new Date() } }],
+                                $or: [{ starts_at: null }, { starts_at: { $lte: now } }],
                             },
                             {
-                                $or: [{ ends_at: null }, { ends_at: { $gt: new Date() } }],
+                                $or: [{ ends_at: null }, { ends_at: { $gt: now } }],
                             },
                         ],
                     },
                 },
             ],
         };
-        return this.listPromotions(activeFilters, config, sharedContext);
+        return await this.promotionService_.list(activeFilters, config, sharedContext);
+    }
+    async registerCampaignBudgetUsageByAttribute_(budgetId, attributeValue, sharedContext = {}) {
+        const [campaignBudgetUsagePerAttributeValue] = await this.campaignBudgetUsageService_.list({
+            budget_id: budgetId,
+            attribute_value: attributeValue,
+        }, { relations: ["budget"] }, sharedContext);
+        if (!campaignBudgetUsagePerAttributeValue) {
+            await this.campaignBudgetUsageService_.create({
+                budget_id: budgetId,
+                attribute_value: attributeValue,
+                used: utils_1.MathBN.convert(1),
+            }, sharedContext);
+        }
+        else {
+            const limit = campaignBudgetUsagePerAttributeValue.budget.limit;
+            const newUsedValue = utils_1.MathBN.add(campaignBudgetUsagePerAttributeValue.used ?? 0, 1);
+            if (limit && utils_1.MathBN.gt(newUsedValue, limit)) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Promotion usage exceeds the budget limit.");
+            }
+            await this.campaignBudgetUsageService_.update({
+                id: campaignBudgetUsagePerAttributeValue.id,
+                used: newUsedValue,
+            }, sharedContext);
+        }
     }
-    async registerUsage(computedActions, sharedContext = {}) {
+    async revertCampaignBudgetUsageByAttribute_(budgetId, attributeValue, sharedContext = {}) {
+        const [campaignBudgetUsagePerAttributeValue] = await this.campaignBudgetUsageService_.list({
+            budget_id: budgetId,
+            attribute_value: attributeValue,
+        }, {}, sharedContext);
+        if (!campaignBudgetUsagePerAttributeValue) {
+            return;
+        }
+        if (utils_1.MathBN.lte(campaignBudgetUsagePerAttributeValue.used ?? 0, 1)) {
+            await this.campaignBudgetUsageService_.delete(campaignBudgetUsagePerAttributeValue.id, sharedContext);
+        }
+        else {
+            await this.campaignBudgetUsageService_.update({
+                id: campaignBudgetUsagePerAttributeValue.id,
+                used: utils_1.MathBN.sub(campaignBudgetUsagePerAttributeValue.used ?? 0, 1),
+            }, sharedContext);
+        }
+    }
+    /**
+     * Register the usage of promotions in the campaign budget and
+     * increment the used value if the budget is not exceeded,
+     * throws an error if the budget is exceeded.
+     *
+     * @param computedActions - The computed actions to register usage for.
+     * @param registrationContext - The context of the campaign budget usage.
+     * @returns void
+     * @throws {MedusaError} - If the promotion usage exceeds the budget limit.
+     */
+    async registerUsage(computedActions, registrationContext, sharedContext = {}) {
         const promotionCodes = computedActions
             .map((computedAction) => computedAction.code)
             .filter(Boolean);
         const campaignBudgetMap = new Map();
         const promotionCodeUsageMap = new Map();
-        const existingPromotions = await this.listActivePromotions({ code: promotionCodes }, { relations: ["campaign", "campaign.budget"] }, sharedContext);
+        const existingPromotions = await this.listActivePromotions_({ code: promotionCodes }, { relations: ["campaign", "campaign.budget", "campaign.budget.usages"] }, sharedContext);
         for (const promotion of existingPromotions) {
             if (promotion.campaign?.budget) {
                 campaignBudgetMap.set(promotion.campaign?.budget.id, promotion.campaign?.budget);
@@ -95,11 +155,13 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 if (!campaignBudgetData) {
                     continue;
                 }
-                campaignBudgetData.used = utils_1.MathBN.add(campaignBudgetData.used ?? 0, computedAction.amount);
+                // Calculate the new budget value
+                const newUsedValue = utils_1.MathBN.add(campaignBudgetData.used ?? 0, computedAction.amount);
                 if (campaignBudget.limit &&
-                    utils_1.MathBN.gt(campaignBudgetData.used, campaignBudget.limit)) {
-                    continue;
+                    utils_1.MathBN.gt(newUsedValue, campaignBudget.limit)) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Promotion usage exceeds the budget limit.");
                 }
+                campaignBudgetData.used = newUsedValue;
                 campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.USAGE) {
@@ -107,28 +169,55 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 if (promotionAlreadyUsed) {
                     continue;
                 }
-                const campaignBudgetData = {
-                    id: campaignBudget.id,
-                    used: utils_1.MathBN.add(campaignBudget.used ?? 0, 1),
-                };
+                const newUsedValue = utils_1.MathBN.add(campaignBudget.used ?? 0, 1);
                 if (campaignBudget.limit &&
-                    utils_1.MathBN.gt(campaignBudgetData.used, campaignBudget.limit)) {
+                    utils_1.MathBN.gt(newUsedValue, campaignBudget.limit)) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_ALLOWED, "Promotion usage exceeds the budget limit.");
+                }
+                campaignBudgetMap.set(campaignBudget.id, {
+                    id: campaignBudget.id,
+                    used: newUsedValue,
+                });
+                promotionCodeUsageMap.set(promotion.code, true);
+            }
+            if (campaignBudget.type === utils_1.CampaignBudgetType.USE_BY_ATTRIBUTE) {
+                const promotionAlreadyUsed = promotionCodeUsageMap.get(promotion.code) || false;
+                if (promotionAlreadyUsed) {
                     continue;
                 }
-                campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+                const attribute = campaignBudget.attribute;
+                const attributeValue = registrationContext[attribute];
+                if (!attributeValue) {
+                    continue;
+                }
+                await this.registerCampaignBudgetUsageByAttribute_(campaignBudget.id, attributeValue, sharedContext);
+                const newUsedValue = utils_1.MathBN.add(campaignBudget.used ?? 0, 1);
+                // update the global budget usage to keep track but it is not used anywhere atm
+                campaignBudgetMap.set(campaignBudget.id, {
+                    id: campaignBudget.id,
+                    used: newUsedValue,
+                });
                 promotionCodeUsageMap.set(promotion.code, true);
             }
+        }
+        if (campaignBudgetMap.size > 0) {
             const campaignBudgetsData = [];
             for (const [_, campaignBudgetData] of campaignBudgetMap) {
+                // usages by attribute are updated separatley
+                if (campaignBudgetData.usages) {
+                    const { usages, ...campaignBudgetDataWithoutUsages } = campaignBudgetData;
+                    campaignBudgetsData.push(campaignBudgetDataWithoutUsages);
+                    continue;
+                }
                 campaignBudgetsData.push(campaignBudgetData);
             }
             await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
         }
     }
-    async revertUsage(computedActions, sharedContext = {}) {
+    async revertUsage(computedActions, registrationContext, sharedContext = {}) {
         const promotionCodeUsageMap = new Map();
         const campaignBudgetMap = new Map();
-        const existingPromotions = await this.listActivePromotions({
+        const existingPromotions = await this.listActivePromotions_({
             code: computedActions
                 .map((computedAction) => computedAction.code)
                 .filter(Boolean),
@@ -153,7 +242,9 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 if (!campaignBudgetData) {
                     continue;
                 }
-                campaignBudgetData.used = utils_1.MathBN.sub(campaignBudgetData.used ?? 0, computedAction.amount);
+                // Calculate new used value and ensure it doesn't go below 0
+                const newUsedValue = utils_1.MathBN.sub(campaignBudgetData.used ?? 0, computedAction.amount);
+                campaignBudgetData.used = utils_1.MathBN.lt(newUsedValue, 0) ? 0 : newUsedValue;
                 campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.USAGE) {
@@ -161,14 +252,44 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 if (promotionAlreadyUsed) {
                     continue;
                 }
+                // Calculate new used value and ensure it doesn't go below 0
+                const newUsedValue = utils_1.MathBN.sub(campaignBudget.used ?? 0, 1);
+                const usedValue = utils_1.MathBN.lt(newUsedValue, 0) ? 0 : newUsedValue;
                 campaignBudgetMap.set(campaignBudget.id, {
                     id: campaignBudget.id,
-                    used: utils_1.MathBN.sub(campaignBudget.used ?? 0, 1),
+                    used: usedValue,
                 });
                 promotionCodeUsageMap.set(promotion.code, true);
             }
+            if (campaignBudget.type === utils_1.CampaignBudgetType.USE_BY_ATTRIBUTE) {
+                const promotionAlreadyUsed = promotionCodeUsageMap.get(promotion.code) || false;
+                if (promotionAlreadyUsed) {
+                    continue;
+                }
+                const attribute = campaignBudget.attribute;
+                const attributeValue = registrationContext[attribute];
+                if (!attributeValue) {
+                    continue;
+                }
+                await this.revertCampaignBudgetUsageByAttribute_(campaignBudget.id, attributeValue, sharedContext);
+                const newUsedValue = utils_1.MathBN.sub(campaignBudget.used ?? 0, 1);
+                const usedValue = utils_1.MathBN.lt(newUsedValue, 0) ? 0 : newUsedValue;
+                // update the global budget usage to keep track but it is not used anywhere atm
+                campaignBudgetMap.set(campaignBudget.id, {
+                    id: campaignBudget.id,
+                    used: usedValue,
+                });
+                promotionCodeUsageMap.set(promotion.code, true);
+            }
+        }
+        if (campaignBudgetMap.size > 0) {
             const campaignBudgetsData = [];
             for (const [_, campaignBudgetData] of campaignBudgetMap) {
+                if (campaignBudgetData.usages) {
+                    const { usages, ...campaignBudgetDataWithoutUsages } = campaignBudgetData;
+                    campaignBudgetsData.push(campaignBudgetDataWithoutUsages);
+                    continue;
+                }
                 campaignBudgetsData.push(campaignBudgetData);
             }
             await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
@@ -178,52 +299,58 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         const { prevent_auto_promotions: preventAutoPromotions } = options;
         const computedActions = [];
         const { items = [], shipping_methods: shippingMethods = [] } = applicationContext;
-        const appliedItemCodes = [];
-        const appliedShippingCodes = [];
         const codeAdjustmentMap = new Map();
+        // Pre-process items and shipping methods to build adjustment map efficiently
+        for (const item of items) {
+            if (!item.adjustments?.length)
+                continue;
+            for (const adjustment of item.adjustments) {
+                if (!(0, utils_1.isString)(adjustment.code))
+                    continue;
+                if (!codeAdjustmentMap.has(adjustment.code)) {
+                    codeAdjustmentMap.set(adjustment.code, { items: [], shipping: [] });
+                }
+                codeAdjustmentMap.get(adjustment.code).items.push(adjustment);
+            }
+        }
+        for (const shippingMethod of shippingMethods) {
+            if (!shippingMethod.adjustments?.length)
+                continue;
+            for (const adjustment of shippingMethod.adjustments) {
+                if (!(0, utils_1.isString)(adjustment.code))
+                    continue;
+                if (!codeAdjustmentMap.has(adjustment.code)) {
+                    codeAdjustmentMap.set(adjustment.code, { items: [], shipping: [] });
+                }
+                codeAdjustmentMap.get(adjustment.code).shipping.push(adjustment);
+            }
+        }
+        const appliedCodes = Array.from(codeAdjustmentMap.keys());
         const methodIdPromoValueMap = new Map();
-        // Keeps a map of all elgible items in the buy section and its eligible quantity
-        const eligibleBuyItemMap = new Map();
-        // Keeps a map of all elgible items in the target section and its eligible quantity
-        const eligibleTargetItemMap = new Map();
-        const automaticPromotions = preventAutoPromotions
-            ? []
-            : await this.listActivePromotions({ is_automatic: true }, { select: ["code"] }, sharedContext);
-        // Promotions we need to apply includes all the codes that are passed as an argument
-        // to this method, along with any automatic promotions that can be applied to the context
-        const automaticPromotionCodes = automaticPromotions.map((p) => p.code);
-        const promotionCodesToApply = [
-            ...promotionCodes,
-            ...automaticPromotionCodes,
-        ];
-        items.forEach((item) => {
-            item.adjustments?.forEach((adjustment) => {
-                if ((0, utils_1.isString)(adjustment.code)) {
-                    const adjustments = codeAdjustmentMap.get(adjustment.code) || [];
-                    adjustments.push(adjustment);
-                    codeAdjustmentMap.set(adjustment.code, adjustments);
-                    appliedItemCodes.push(adjustment.code);
+        const promotionCodesToApply = [...promotionCodes, ...appliedCodes];
+        const uniquePromotionCodes = Array.from(new Set(promotionCodesToApply));
+        let queryFilter = { code: uniquePromotionCodes };
+        if (!preventAutoPromotions) {
+            const rulePrefilteringFilters = await (0, build_promotion_rule_query_filter_from_context_1.buildPromotionRuleQueryFilterFromContext)(applicationContext, sharedContext);
+            let prefilteredAutomaticPromotionIds = [];
+            if (rulePrefilteringFilters) {
+                const promotions = await this.promotionService_.list({
+                    $and: [{ is_automatic: true }, rulePrefilteringFilters],
+                }, { select: ["id"] }, sharedContext);
+                prefilteredAutomaticPromotionIds = promotions.map((promotion) => promotion.id);
+            }
+            const automaticPromotionFilter = rulePrefilteringFilters
+                ? {
+                    id: { $in: prefilteredAutomaticPromotionIds },
                 }
-            });
-        });
-        shippingMethods.forEach((shippingMethod) => {
-            shippingMethod.adjustments?.forEach((adjustment) => {
-                if ((0, utils_1.isString)(adjustment.code)) {
-                    const adjustments = codeAdjustmentMap.get(adjustment.code) || [];
-                    adjustments.push(adjustment);
-                    codeAdjustmentMap.set(adjustment.code, adjustments);
-                    appliedShippingCodes.push(adjustment.code);
+                : { is_automatic: true };
+            queryFilter = automaticPromotionFilter
+                ? {
+                    $or: [{ code: uniquePromotionCodes }, automaticPromotionFilter],
                 }
-            });
-        });
-        const promotions = await this.listActivePromotions({
-            code: [
-                ...promotionCodesToApply,
-                ...appliedItemCodes,
-                ...appliedShippingCodes,
-            ],
-        }, {
-            take: null,
+                : queryFilter;
+        }
+        const promotions = await this.listActivePromotions_(queryFilter, {
             order: { application_method: { value: "DESC" } },
             relations: [
                 "application_method",
@@ -236,43 +363,74 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 "campaign",
                 "campaign.budget",
             ],
-        });
+        }, sharedContext);
         const existingPromotionsMap = new Map(promotions.map((promotion) => [promotion.code, promotion]));
-        // We look at any existing promo codes applied in the context and recommend
-        // them to be removed to start calculations from the beginning and refresh
-        // the adjustments if they are requested to be applied again
-        const appliedCodes = [...appliedShippingCodes, ...appliedItemCodes];
-        for (const appliedCode of appliedCodes) {
-            const adjustments = codeAdjustmentMap.get(appliedCode) || [];
-            const action = appliedShippingCodes.includes(appliedCode)
-                ? utils_1.ComputedActions.REMOVE_SHIPPING_METHOD_ADJUSTMENT
-                : utils_1.ComputedActions.REMOVE_ITEM_ADJUSTMENT;
-            adjustments.forEach((adjustment) => computedActions.push({
-                action,
-                adjustment_id: adjustment.id,
-                code: appliedCode,
-            }));
+        const automaticPromotionCodes = [];
+        for (const promotion of promotions) {
+            if (promotion.is_automatic) {
+                automaticPromotionCodes.push(promotion.code);
+            }
         }
-        // We sort the promo codes to apply with buy get type first as they
-        // are likely to be most valuable.
-        const sortedPermissionsToApply = promotions
-            .filter((p) => promotionCodesToApply.includes(p.code))
+        for (const [code, adjustments] of codeAdjustmentMap.entries()) {
+            for (const adjustment of adjustments.items) {
+                computedActions.push({
+                    action: utils_1.ComputedActions.REMOVE_ITEM_ADJUSTMENT,
+                    adjustment_id: adjustment.id,
+                    code,
+                });
+            }
+            for (const adjustment of adjustments.shipping) {
+                computedActions.push({
+                    action: utils_1.ComputedActions.REMOVE_SHIPPING_METHOD_ADJUSTMENT,
+                    adjustment_id: adjustment.id,
+                    code,
+                });
+            }
+        }
+        const promotionCodeSet = new Set(promotionCodes);
+        const automaticPromotionCodeSet = new Set(automaticPromotionCodes);
+        const sortedPromotionsToApply = promotions
+            .filter((p) => promotionCodeSet.has(p.code) ||
+            automaticPromotionCodeSet.has(p.code))
             .sort(_utils_1.ComputeActionUtils.sortByBuyGetType);
-        for (const promotionToApply of sortedPermissionsToApply) {
+        const eligibleBuyItemMap = new Map();
+        const eligibleTargetItemMap = new Map();
+        for (const promotionToApply of sortedPromotionsToApply) {
             const promotion = existingPromotionsMap.get(promotionToApply.code);
-            const { application_method: applicationMethod, rules: promotionRules = [], } = promotion;
-            if (!applicationMethod) {
+            if (!promotion.application_method) {
                 continue;
             }
+            const { application_method: applicationMethod, rules: promotionRules = [], } = promotion;
+            if (promotion.campaign?.budget?.type === utils_1.CampaignBudgetType.USE_BY_ATTRIBUTE) {
+                const attribute = promotion.campaign?.budget?.attribute;
+                const budgetUsageContext = _utils_1.ComputeActionUtils.getBudgetUsageContextFromComputeActionContext(applicationContext);
+                const attributeValue = budgetUsageContext[attribute];
+                if (!attributeValue) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Attribute value for "${attribute}" is required by promotion campaing budget`);
+                }
+                const [campaignBudgetUsagePerAttribute] = (await this.campaignBudgetUsageService_.list({
+                    budget_id: promotion.campaign?.budget?.id,
+                    attribute_value: attributeValue,
+                }, {}, sharedContext));
+                if (campaignBudgetUsagePerAttribute) {
+                    const action = _utils_1.ComputeActionUtils.computeActionForBudgetExceeded(promotion, 1, campaignBudgetUsagePerAttribute);
+                    if (action) {
+                        computedActions.push(action);
+                        continue;
+                    }
+                }
+            }
+            const isCurrencyCodeValid = !(0, utils_1.isPresent)(applicationMethod.currency_code) ||
+                applicationContext.currency_code === applicationMethod.currency_code;
             const isPromotionApplicable = (0, _utils_1.areRulesValidForContext)(promotionRules, applicationContext, utils_1.ApplicationMethodTargetType.ORDER);
-            if (!isPromotionApplicable) {
+            if (!isPromotionApplicable || !isCurrencyCodeValid) {
                 continue;
             }
             if (promotion.type === utils_1.PromotionType.BUYGET) {
                 const computedActionsForItems = _utils_1.ComputeActionUtils.getComputedActionsForBuyGet(promotion, applicationContext[utils_1.ApplicationMethodTargetType.ITEMS], methodIdPromoValueMap, eligibleBuyItemMap, eligibleTargetItemMap);
                 computedActions.push(...computedActionsForItems);
             }
-            if (promotion.type === utils_1.PromotionType.STANDARD) {
+            else if (promotion.type === utils_1.PromotionType.STANDARD) {
                 const isTargetOrder = applicationMethod.target_type === utils_1.ApplicationMethodTargetType.ORDER;
                 const isTargetItems = applicationMethod.target_type === utils_1.ApplicationMethodTargetType.ITEMS;
                 const isTargetShipping = applicationMethod.target_type ===
@@ -310,13 +468,19 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 "campaign.budget",
             ],
         }, sharedContext);
-        return Array.isArray(data) ? promotions : promotions[0];
+        return await this.baseRepository_.serialize(Array.isArray(data) ? promotions : promotions[0]);
     }
     async createPromotions_(data, sharedContext = {}) {
         const promotionsData = [];
         const applicationMethodsData = [];
         const campaignsData = [];
-        const existingCampaigns = await this.campaignService_.list({ id: data.map((d) => d.campaign_id).filter((id) => (0, utils_1.isString)(id)) }, { relations: ["budget"] }, sharedContext);
+        const campaignIds = data
+            .filter((d) => d.campaign_id)
+            .map((d) => d.campaign_id)
+            .filter((id) => (0, utils_1.isString)(id));
+        const existingCampaigns = campaignIds.length > 0
+            ? await this.campaignService_.list({ id: campaignIds }, { relations: ["budget"] }, sharedContext)
+            : [];
         const promotionCodeApplicationMethodDataMap = new Map();
         const promotionCodeRulesDataMap = new Map();
         const methodTargetRulesMap = new Map();
@@ -390,21 +554,32 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                     methodBuyRulesMap.set(promotion.id, buyRulesData);
                 }
             }
-            await this.createPromotionRulesAndValues_(promotionCodeRulesDataMap.get(promotion.code) || [], "promotions", promotion, sharedContext);
+            if (promotionCodeRulesDataMap.has(promotion.code)) {
+                await this.createPromotionRulesAndValues_(promotionCodeRulesDataMap.get(promotion.code) || [], "promotions", promotion, sharedContext);
+            }
         }
-        const createdApplicationMethods = await this.applicationMethodService_.create(applicationMethodsData, sharedContext);
-        const createdCampaigns = await this.createCampaigns(campaignsData, sharedContext);
+        const createdApplicationMethods = applicationMethodsData.length > 0
+            ? await this.applicationMethodService_.create(applicationMethodsData, sharedContext)
+            : [];
+        const createdCampaigns = campaignsData.length > 0
+            ? await this.createCampaigns(campaignsData, sharedContext)
+            : [];
         for (const campaignData of campaignsData) {
             const promotions = campaignData.promotions;
             const campaign = createdCampaigns.find((c) => c.campaign_identifier === campaignData.campaign_identifier);
-            if (!campaign || !promotions || !promotions.length) {
-                continue;
+            if (campaign && promotions && promotions.length) {
+                await this.addPromotionsToCampaign({ id: campaign.id, promotion_ids: promotions.map((p) => p.id) }, sharedContext);
             }
-            await this.addPromotionsToCampaign({ id: campaign.id, promotion_ids: promotions.map((p) => p.id) }, sharedContext);
         }
         for (const applicationMethod of createdApplicationMethods) {
-            await this.createPromotionRulesAndValues_(methodTargetRulesMap.get(applicationMethod.promotion.id) || [], "method_target_rules", applicationMethod, sharedContext);
-            await this.createPromotionRulesAndValues_(methodBuyRulesMap.get(applicationMethod.promotion.id) || [], "method_buy_rules", applicationMethod, sharedContext);
+            const targetRules = methodTargetRulesMap.get(applicationMethod.promotion.id);
+            if (targetRules && targetRules.length > 0) {
+                await this.createPromotionRulesAndValues_(targetRules, "method_target_rules", applicationMethod, sharedContext);
+            }
+            const buyRules = methodBuyRulesMap.get(applicationMethod.promotion.id);
+            if (buyRules && buyRules.length > 0) {
+                await this.createPromotionRulesAndValues_(buyRules, "method_buy_rules", applicationMethod, sharedContext);
+            }
         }
         return createdPromotions;
     }
@@ -479,12 +654,17 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
     }
     async updatePromotionRules_(data, sharedContext = {}) {
         const promotionRuleIds = data.map((d) => d.id);
-        const promotionRules = await this.listPromotionRules({ id: promotionRuleIds }, { relations: ["values"] }, sharedContext);
-        const invalidRuleId = (0, utils_1.arrayDifference)((0, utils_1.deduplicate)(promotionRuleIds), promotionRules.map((pr) => pr.id));
+        const promotionRules = await this.promotionRuleService_.list({ id: promotionRuleIds }, { relations: ["values"] }, sharedContext);
+        const existingPromotionRuleIds = [];
+        const promotionRulesMap = new Map();
+        for (const promotionRule of promotionRules) {
+            existingPromotionRuleIds.push(promotionRule.id);
+            promotionRulesMap.set(promotionRule.id, promotionRule);
+        }
+        const invalidRuleId = (0, utils_1.arrayDifference)((0, utils_1.deduplicate)(promotionRuleIds), existingPromotionRuleIds);
         if (invalidRuleId.length) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Promotion rules with id - ${invalidRuleId.join(", ")} not found`);
         }
-        const promotionRulesMap = new Map(promotionRules.map((pr) => [pr.id, pr]));
         const rulesToUpdate = [];
         const ruleValueIdsToDelete = [];
         const ruleValuesToCreate = [];
@@ -547,6 +727,7 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Can't add buy rules to a ${utils_1.PromotionType.STANDARD} promotion`);
         }
         (0, _utils_1.validatePromotionRuleAttributes)(rulesData);
+        const promotionRuleValuesDataToCreate = [];
         for (const ruleData of rulesData) {
             const { values, ...rest } = ruleData;
             const promotionRuleData = {
@@ -560,8 +741,9 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 value: ruleValue,
                 promotion_rule: createdPromotionRule,
             }));
-            await this.promotionRuleValueService_.create(promotionRuleValuesData, sharedContext);
+            promotionRuleValuesDataToCreate.push(...promotionRuleValuesData);
         }
+        await this.promotionRuleValueService_.create(promotionRuleValuesDataToCreate, sharedContext);
         return createdPromotionRules;
     }
     async removePromotionRules(promotionId, ruleIds, sharedContext = {}) {
@@ -651,7 +833,7 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         const campaignsData = [];
         const updateBudgetData = [];
         const createBudgetData = [];
-        const existingCampaigns = await this.listCampaigns({ id: campaignIds }, { relations: ["budget"] }, sharedContext);
+        const existingCampaigns = await this.campaignService_.list({ id: campaignIds }, { relations: ["budget"] }, sharedContext);
         const existingCampaignsMap = new Map(existingCampaigns.map((campaign) => [campaign.id, campaign]));
         for (const updateCampaignData of data) {
             const { budget: budgetData, ...campaignData } = updateCampaignData;
@@ -689,7 +871,7 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }
         return updatedCampaigns;
     }
-    async addPromotionsToCampaign(data, sharedContext) {
+    async addPromotionsToCampaign(data, sharedContext = {}) {
         const ids = await this.addPromotionsToCampaign_(data, sharedContext);
         return { ids };
     }
@@ -717,7 +899,7 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         })), sharedContext);
         return promotionsToAdd.map((promo) => promo.id);
     }
-    async removePromotionsFromCampaign(data, sharedContext) {
+    async removePromotionsFromCampaign(data, sharedContext = {}) {
         const ids = await this.removePromotionsFromCampaign_(data, sharedContext);
         return { ids };
     }
@@ -745,17 +927,50 @@ __decorate([
 ], PromotionModuleService.prototype, "listActivePromotions", null);
 __decorate([
     (0, utils_1.InjectManager)(),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "listActivePromotions_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "registerCampaignBudgetUsageByAttribute_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, String, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "revertCampaignBudgetUsageByAttribute_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    /**
+     * Register the usage of promotions in the campaign budget and
+     * increment the used value if the budget is not exceeded,
+     * throws an error if the budget is exceeded.
+     *
+     * @param computedActions - The computed actions to register usage for.
+     * @param registrationContext - The context of the campaign budget usage.
+     * @returns void
+     * @throws {MedusaError} - If the promotion usage exceeds the budget limit.
+     */
+    ,
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "registerUsage", null);
 __decorate([
-    (0, utils_1.InjectManager)(),
-    __param(1, (0, utils_1.MedusaContext)()),
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Array, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "revertUsage", null);
 __decorate([
@@ -766,7 +981,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "computeActions", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -782,7 +998,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "createPromotions_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -798,7 +1015,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updatePromotions_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -815,6 +1033,7 @@ __decorate([
 ], PromotionModuleService.prototype, "updatePromotionRules_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -822,6 +1041,7 @@ __decorate([
 ], PromotionModuleService.prototype, "addPromotionRules", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -829,6 +1049,7 @@ __decorate([
 ], PromotionModuleService.prototype, "addPromotionTargetRules", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -843,6 +1064,7 @@ __decorate([
 ], PromotionModuleService.prototype, "createPromotionRulesAndValues_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -857,6 +1079,7 @@ __decorate([
 ], PromotionModuleService.prototype, "removePromotionRules_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
@@ -877,7 +1100,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removeApplicationMethodRules_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -893,7 +1117,8 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "createCampaigns_", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(1, (0, utils_1.MedusaContext)()),
@@ -910,6 +1135,8 @@ __decorate([
 ], PromotionModuleService.prototype, "updateCampaigns_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
@@ -923,6 +1150,8 @@ __decorate([
 ], PromotionModuleService.prototype, "addPromotionsToCampaign_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)