@medusajs/promotion 0.0.6 → 1.0.0-rc-20241003153304

package/dist/services/promotion-module.js

@@ -12,20 +12,20 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const types_1 = require("@medusajs/types");
-const utils_1 = require("@medusajs/utils");
+const types_1 = require("@medusajs/framework/types");
+const utils_1 = require("@medusajs/framework/utils");
 const _models_1 = require("../models");
 const _types_1 = require("../types");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
-const generateMethodForModels = [
-    _models_1.ApplicationMethod,
-    _models_1.Campaign,
-    _models_1.CampaignBudget,
-    _models_1.PromotionRule,
-    _models_1.PromotionRuleValue,
-];
-class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.Promotion, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+class PromotionModuleService extends (0, utils_1.MedusaService)({
+    Promotion: _models_1.Promotion,
+    ApplicationMethod: _models_1.ApplicationMethod,
+    Campaign: _models_1.Campaign,
+    CampaignBudget: _models_1.CampaignBudget,
+    PromotionRule: _models_1.PromotionRule,
+    PromotionRuleValue: _models_1.PromotionRuleValue,
+}) {
     constructor({ baseRepository, promotionService, applicationMethodService, promotionRuleService, promotionRuleValueService, campaignService, campaignBudgetService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
@@ -45,14 +45,18 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         const promotionCodes = computedActions
             .map((computedAction) => computedAction.code)
             .filter(Boolean);
-        const promotionCodeCampaignBudgetMap = new Map();
+        const campaignBudgetMap = new Map();
         const promotionCodeUsageMap = new Map();
-        const existingPromotions = await this.list({ code: promotionCodes }, { relations: ["application_method", "campaign", "campaign.budget"] }, sharedContext);
+        const existingPromotions = await this.listPromotions({ code: promotionCodes }, {
+            relations: ["campaign", "campaign.budget"],
+        }, sharedContext);
+        for (const promotion of existingPromotions) {
+            if (promotion.campaign?.budget) {
+                campaignBudgetMap.set(promotion.campaign?.budget.id, promotion.campaign?.budget);
+            }
+        }
         const existingPromotionsMap = new Map(existingPromotions.map((promotion) => [promotion.code, promotion]));
         for (let computedAction of computedActions) {
-            if (!_utils_1.ComputeActionUtils.canRegisterUsage(computedAction)) {
-                continue;
-            }
             const promotion = existingPromotionsMap.get(computedAction.code);
             if (!promotion) {
                 continue;
@@ -62,14 +66,16 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 continue;
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.SPEND) {
-                const campaignBudgetData = promotionCodeCampaignBudgetMap.get(campaignBudget.id) || { id: campaignBudget.id, used: campaignBudget.used ?? 0 };
-                campaignBudgetData.used =
-                    (campaignBudgetData.used ?? 0) + computedAction.amount;
+                const campaignBudgetData = campaignBudgetMap.get(campaignBudget.id);
+                if (!campaignBudgetData) {
+                    continue;
+                }
+                campaignBudgetData.used = utils_1.MathBN.add(campaignBudgetData.used ?? 0, computedAction.amount);
                 if (campaignBudget.limit &&
-                    campaignBudgetData.used > campaignBudget.limit) {
+                    utils_1.MathBN.gt(campaignBudgetData.used, campaignBudget.limit)) {
                     continue;
                 }
-                promotionCodeCampaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+                campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.USAGE) {
                 const promotionAlreadyUsed = promotionCodeUsageMap.get(promotion.code) || false;
@@ -78,17 +84,68 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 }
                 const campaignBudgetData = {
                     id: campaignBudget.id,
-                    used: (campaignBudget.used ?? 0) + 1,
+                    used: utils_1.MathBN.add(campaignBudget.used ?? 0, 1),
                 };
                 if (campaignBudget.limit &&
-                    campaignBudgetData.used > campaignBudget.limit) {
+                    utils_1.MathBN.gt(campaignBudgetData.used, campaignBudget.limit)) {
+                    continue;
+                }
+                campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+                promotionCodeUsageMap.set(promotion.code, true);
+            }
+            const campaignBudgetsData = [];
+            for (const [_, campaignBudgetData] of campaignBudgetMap) {
+                campaignBudgetsData.push(campaignBudgetData);
+            }
+            await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
+        }
+    }
+    async revertUsage(computedActions, sharedContext = {}) {
+        const promotionCodeUsageMap = new Map();
+        const campaignBudgetMap = new Map();
+        const existingPromotions = await this.listPromotions({
+            code: computedActions
+                .map((computedAction) => computedAction.code)
+                .filter(Boolean),
+        }, {
+            relations: ["campaign", "campaign.budget"],
+        }, sharedContext);
+        for (const promotion of existingPromotions) {
+            if (promotion.campaign?.budget) {
+                campaignBudgetMap.set(promotion.campaign?.budget.id, promotion.campaign?.budget);
+            }
+        }
+        const existingPromotionsMap = new Map(existingPromotions.map((promotion) => [promotion.code, promotion]));
+        for (let computedAction of computedActions) {
+            const promotion = existingPromotionsMap.get(computedAction.code);
+            if (!promotion) {
+                continue;
+            }
+            const campaignBudget = promotion.campaign?.budget;
+            if (!campaignBudget) {
+                continue;
+            }
+            if (campaignBudget.type === utils_1.CampaignBudgetType.SPEND) {
+                const campaignBudgetData = campaignBudgetMap.get(campaignBudget.id);
+                if (!campaignBudgetData) {
+                    continue;
+                }
+                campaignBudgetData.used = utils_1.MathBN.sub(campaignBudgetData.used ?? 0, computedAction.amount);
+                campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+            }
+            if (campaignBudget.type === utils_1.CampaignBudgetType.USAGE) {
+                const promotionAlreadyUsed = promotionCodeUsageMap.get(promotion.code) || false;
+                if (promotionAlreadyUsed) {
                     continue;
                 }
-                promotionCodeCampaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+                campaignBudgetMap.set(campaignBudget.id, {
+                    id: campaignBudget.id,
+                    used: utils_1.MathBN.sub(campaignBudget.used ?? 0, 1),
+                });
                 promotionCodeUsageMap.set(promotion.code, true);
             }
             const campaignBudgetsData = [];
-            for (const [_, campaignBudgetData] of promotionCodeCampaignBudgetMap) {
+            for (const [_, campaignBudgetData] of campaignBudgetMap) {
                 campaignBudgetsData.push(campaignBudgetData);
             }
             await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
@@ -102,9 +159,13 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         const appliedShippingCodes = [];
         const codeAdjustmentMap = new Map();
         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.list({ is_automatic: true }, { select: ["code"], take: null }, sharedContext);
+            : await this.listPromotions({ 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);
@@ -132,7 +193,7 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 }
             });
         });
-        const promotions = await this.list({
+        const promotions = await this.listPromotions({
             code: [
                 ...promotionCodesToApply,
                 ...appliedItemCodes,
@@ -150,7 +211,6 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 "campaign",
                 "campaign.budget",
             ],
-            take: null,
         });
         const existingPromotionsMap = new Map(promotions.map((promotion) => [promotion.code, promotion]));
         // We look at any existing promo codes applied in the context and recommend
@@ -183,12 +243,12 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
             if (!applicationMethod) {
                 continue;
             }
-            const isPromotionApplicable = (0, _utils_1.areRulesValidForContext)(promotionRules, applicationContext);
+            const isPromotionApplicable = (0, _utils_1.areRulesValidForContext)(promotionRules, applicationContext, utils_1.ApplicationMethodTargetType.ORDER);
             if (!isPromotionApplicable) {
                 continue;
             }
             if (promotion.type === utils_1.PromotionType.BUYGET) {
-                const computedActionsForItems = _utils_1.ComputeActionUtils.getComputedActionsForBuyGet(promotion, applicationContext[utils_1.ApplicationMethodTargetType.ITEMS], methodIdPromoValueMap);
+                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) {
@@ -209,12 +269,13 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 }
             }
         }
+        (0, utils_1.transformPropertiesToBigNumber)(computedActions, { include: ["amount"] });
         return computedActions;
     }
-    async create(data, sharedContext = {}) {
+    async createPromotions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const createdPromotions = await this.create_(input, sharedContext);
-        const promotions = await this.list({ id: createdPromotions.map((p) => p.id) }, {
+        const createdPromotions = await this.createPromotions_(input, sharedContext);
+        const promotions = await this.listPromotions({ id: createdPromotions.map((p) => p.id) }, {
             relations: [
                 "application_method",
                 "application_method.target_rules",
@@ -226,35 +287,48 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 "campaign",
                 "campaign.budget",
             ],
-            take: null,
         }, sharedContext);
         return Array.isArray(data) ? promotions : promotions[0];
     }
-    async create_(data, sharedContext = {}) {
+    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 promotionCodeApplicationMethodDataMap = new Map();
         const promotionCodeRulesDataMap = new Map();
         const methodTargetRulesMap = new Map();
         const methodBuyRulesMap = new Map();
         const promotionCodeCampaignMap = new Map();
         for (const { application_method: applicationMethodData, rules: rulesData, campaign: campaignData, campaign_id: campaignId, ...promotionData } of data) {
-            if (applicationMethodData) {
-                promotionCodeApplicationMethodDataMap.set(promotionData.code, applicationMethodData);
-            }
+            promotionCodeApplicationMethodDataMap.set(promotionData.code, applicationMethodData);
             if (rulesData) {
                 promotionCodeRulesDataMap.set(promotionData.code, rulesData);
             }
             if (campaignData && campaignId) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Provide either the 'campaign' or 'campaign_id' parameter; both cannot be used simultaneously.`);
             }
+            if (!campaignData && !campaignId) {
+                promotionsData.push({ ...promotionData });
+                continue;
+            }
+            const existingCampaign = existingCampaigns.find((c) => c.id === campaignId);
+            if (campaignId && !existingCampaign) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Could not find campaign with id - ${campaignId}`);
+            }
+            const campaignCurrency = campaignData?.budget?.currency_code ||
+                existingCampaigns.find((c) => c.id === campaignId)?.budget
+                    ?.currency_code;
+            if (campaignData?.budget?.type === utils_1.CampaignBudgetType.SPEND &&
+                campaignCurrency !== applicationMethodData?.currency_code) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Currency between promotion and campaigns should match`);
+            }
             if (campaignData) {
                 promotionCodeCampaignMap.set(promotionData.code, campaignData);
             }
             promotionsData.push({
                 ...promotionData,
-                campaign: campaignId,
+                campaign_id: campaignId,
             });
         }
         const createdPromotions = await this.promotionService_.create(promotionsData, sharedContext);
@@ -297,8 +371,14 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
             await this.createPromotionRulesAndValues_(promotionCodeRulesDataMap.get(promotion.code) || [], "promotions", promotion, sharedContext);
         }
         const createdApplicationMethods = await this.applicationMethodService_.create(applicationMethodsData, sharedContext);
-        if (campaignsData.length) {
-            await this.createCampaigns(campaignsData, sharedContext);
+        const createdCampaigns = 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;
+            }
+            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);
@@ -306,10 +386,10 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         }
         return createdPromotions;
     }
-    async update(data, sharedContext = {}) {
+    async updatePromotions(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const updatedPromotions = await this.update_(input, sharedContext);
-        const promotions = await this.list({ id: updatedPromotions.map((p) => p.id) }, {
+        const updatedPromotions = await this.updatePromotions_(input, sharedContext);
+        const promotions = await this.listPromotions({ id: updatedPromotions.map((p) => p.id) }, {
             relations: [
                 "application_method",
                 "application_method.target_rules",
@@ -319,29 +399,37 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
                 "campaign",
                 "campaign.budget",
             ],
-            take: null,
         }, sharedContext);
         return Array.isArray(data) ? promotions : promotions[0];
     }
-    async update_(data, sharedContext = {}) {
+    async updatePromotions_(data, sharedContext = {}) {
         const promotionIds = data.map((d) => d.id);
         const existingPromotions = await this.promotionService_.list({ id: promotionIds }, { relations: ["application_method"] });
+        const existingCampaigns = await this.campaignService_.list({ id: data.map((d) => d.campaign_id).filter((d) => (0, utils_1.isPresent)(d)) }, { relations: ["budget"] });
         const existingPromotionsMap = new Map(existingPromotions.map((promotion) => [promotion.id, promotion]));
         const promotionsData = [];
         const applicationMethodsData = [];
         for (const { application_method: applicationMethodData, campaign_id: campaignId, ...promotionData } of data) {
-            if (campaignId) {
-                promotionsData.push({ ...promotionData, campaign: campaignId });
+            const existingCampaign = existingCampaigns.find((c) => c.id === campaignId);
+            const existingPromotion = existingPromotionsMap.get(promotionData.id);
+            const existingApplicationMethod = existingPromotion?.application_method;
+            const promotionCurrencyCode = existingApplicationMethod?.currency_code ||
+                applicationMethodData?.currency_code;
+            if (campaignId && !existingCampaign) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Could not find campaign with id ${campaignId}`);
+            }
+            if (campaignId &&
+                existingCampaign?.budget?.type === utils_1.CampaignBudgetType.SPEND &&
+                existingCampaign.budget.currency_code !== promotionCurrencyCode) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Currency code doesn't match for campaign (${campaignId}) and promotion (${existingPromotion.id})`);
+            }
+            if ((0, utils_1.isDefined)(campaignId)) {
+                promotionsData.push({ ...promotionData, campaign_id: campaignId });
             }
             else {
                 promotionsData.push(promotionData);
             }
-            if (!applicationMethodData) {
-                continue;
-            }
-            const existingPromotion = existingPromotionsMap.get(promotionData.id);
-            const existingApplicationMethod = existingPromotion?.application_method;
-            if (!existingApplicationMethod) {
+            if (!applicationMethodData || !existingApplicationMethod) {
                 continue;
             }
             if (applicationMethodData.allocation &&
@@ -361,9 +449,10 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         }
         return updatedPromotions;
     }
+    // @ts-ignore
     async updatePromotionRules(data, sharedContext = {}) {
         const updatedPromotionRules = await this.updatePromotionRules_(data, sharedContext);
-        return this.listPromotionRules({ id: updatedPromotionRules.map((r) => r.id) }, { relations: ["values"] }, sharedContext);
+        return await this.listPromotionRules({ id: updatedPromotionRules.map((r) => r.id) }, { relations: ["values"] }, sharedContext);
     }
     async updatePromotionRules_(data, sharedContext = {}) {
         const promotionRuleIds = data.map((d) => d.id);
@@ -413,9 +502,7 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         return await this.listPromotionRules({ id: createdPromotionRules.map((pr) => pr.id) }, { relations: ["values"] }, sharedContext);
     }
     async addPromotionBuyRules(promotionId, rulesData, sharedContext = {}) {
-        const promotion = await this.promotionService_.retrieve(promotionId, {
-            relations: ["application_method"],
-        });
+        const promotion = await this.promotionService_.retrieve(promotionId, { relations: ["application_method"] }, sharedContext);
         const applicationMethod = promotion.application_method;
         if (!applicationMethod) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `application_method for promotion not found`);
@@ -482,7 +569,6 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         const createdCampaigns = await this.createCampaigns_(input, sharedContext);
         const campaigns = await this.listCampaigns({ id: createdCampaigns.map((p) => p.id) }, {
             relations: ["budget", "promotions"],
-            take: null,
         }, sharedContext);
         return Array.isArray(data) ? campaigns : campaigns[0];
     }
@@ -491,22 +577,19 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         const campaignBudgetsData = [];
         const campaignIdentifierBudgetMap = new Map();
         for (const createCampaignData of data) {
-            const { budget: campaignBudgetData, promotions, ...campaignData } = createCampaignData;
-            const promotionsToAdd = promotions
-                ? await this.list({ id: promotions.map((p) => p.id) }, { take: null }, sharedContext)
-                : [];
+            const { budget: campaignBudgetData, ...campaignData } = createCampaignData;
             if (campaignBudgetData) {
                 campaignIdentifierBudgetMap.set(campaignData.campaign_identifier, campaignBudgetData);
             }
             campaignsData.push({
                 ...campaignData,
-                promotions: promotionsToAdd,
             });
         }
         const createdCampaigns = await this.campaignService_.create(campaignsData, sharedContext);
         for (const createdCampaign of createdCampaigns) {
             const campaignBudgetData = campaignIdentifierBudgetMap.get(createdCampaign.campaign_identifier);
             if (campaignBudgetData) {
+                this.validateCampaignBudgetData(campaignBudgetData);
                 campaignBudgetsData.push({
                     ...campaignBudgetData,
                     campaign: createdCampaign.id,
@@ -518,185 +601,295 @@ class PromotionModuleService extends utils_1.ModulesSdkUtils.abstractModuleServi
         }
         return createdCampaigns;
     }
+    validateCampaignBudgetData(data) {
+        if (!data.type) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Campaign Budget type is a required field`);
+        }
+        if (data.type === utils_1.CampaignBudgetType.SPEND &&
+            !(0, utils_1.isPresent)(data.currency_code)) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Campaign Budget type is a required field`);
+        }
+    }
     async updateCampaigns(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const updatedCampaigns = await this.updateCampaigns_(input, sharedContext);
         const campaigns = await this.listCampaigns({ id: updatedCampaigns.map((p) => p.id) }, {
             relations: ["budget", "promotions"],
-            take: null,
         }, sharedContext);
         return Array.isArray(data) ? campaigns : campaigns[0];
     }
     async updateCampaigns_(data, sharedContext = {}) {
         const campaignIds = data.map((d) => d.id);
         const campaignsData = [];
-        const campaignBudgetsData = [];
-        const existingCampaigns = await this.listCampaigns({ id: campaignIds }, { relations: ["budget"], take: null }, sharedContext);
+        const updateBudgetData = [];
+        const createBudgetData = [];
+        const existingCampaigns = await this.listCampaigns({ id: campaignIds }, { relations: ["budget"] }, sharedContext);
         const existingCampaignsMap = new Map(existingCampaigns.map((campaign) => [campaign.id, campaign]));
         for (const updateCampaignData of data) {
-            const { budget: campaignBudgetData, ...campaignData } = updateCampaignData;
+            const { budget: budgetData, ...campaignData } = updateCampaignData;
             const existingCampaign = existingCampaignsMap.get(campaignData.id);
-            const existingCampaignBudget = existingCampaign?.budget;
             campaignsData.push(campaignData);
-            if (existingCampaignBudget && campaignBudgetData) {
-                campaignBudgetsData.push({
-                    id: existingCampaignBudget.id,
-                    ...campaignBudgetData,
-                });
+            // Type & currency code of the budget is immutable, we don't allow for it to be updated.
+            // If an existing budget is present, we remove the type and currency from being updated
+            if ((existingCampaign?.budget && budgetData?.type) ||
+                budgetData?.currency_code) {
+                delete budgetData?.type;
+                delete budgetData?.currency_code;
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Campaign budget attributes (type, currency_code) are immutable`);
+            }
+            if (budgetData) {
+                if (existingCampaign?.budget) {
+                    updateBudgetData.push({
+                        id: existingCampaign.budget.id,
+                        ...budgetData,
+                    });
+                }
+                else {
+                    createBudgetData.push({
+                        ...budgetData,
+                        campaign: existingCampaign.id,
+                    });
+                }
             }
         }
         const updatedCampaigns = await this.campaignService_.update(campaignsData, sharedContext);
-        if (campaignBudgetsData.length) {
-            await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
+        if (updateBudgetData.length) {
+            await this.campaignBudgetService_.update(updateBudgetData, sharedContext);
+        }
+        if (createBudgetData.length) {
+            await this.campaignBudgetService_.create(createBudgetData, sharedContext);
         }
         return updatedCampaigns;
     }
+    async addPromotionsToCampaign(data, sharedContext) {
+        const ids = await this.addPromotionsToCampaign_(data, sharedContext);
+        return { ids };
+    }
+    // TODO:
+    // - introduce currency_code to promotion
+    // - allow promotions to be queried by currency code
+    // - when the above is present, validate adding promotion to campaign based on currency code
+    async addPromotionsToCampaign_(data, sharedContext = {}) {
+        const { id, promotion_ids: promotionIds = [] } = data;
+        const campaign = await this.campaignService_.retrieve(id, {}, sharedContext);
+        const promotionsToAdd = await this.promotionService_.list({ id: promotionIds, campaign_id: null }, { relations: ["application_method"] }, sharedContext);
+        const diff = (0, utils_1.arrayDifference)(promotionsToAdd.map((p) => p.id), promotionIds);
+        if (diff.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Cannot add promotions (${diff.join(",")}) to campaign. These promotions are either already part of a campaign or not found.`);
+        }
+        const promotionsWithInvalidCurrency = promotionsToAdd.filter((promotion) => campaign.budget?.type === utils_1.CampaignBudgetType.SPEND &&
+            promotion.application_method?.currency_code !==
+                campaign?.budget?.currency_code);
+        if (promotionsWithInvalidCurrency.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot add promotions to campaign where currency_code don't match.`);
+        }
+        await this.promotionService_.update(promotionsToAdd.map((promotion) => ({
+            id: promotion.id,
+            campaign_id: campaign.id,
+        })), sharedContext);
+        return promotionsToAdd.map((promo) => promo.id);
+    }
+    async removePromotionsFromCampaign(data, sharedContext) {
+        const ids = await this.removePromotionsFromCampaign_(data, sharedContext);
+        return { ids };
+    }
+    async removePromotionsFromCampaign_(data, sharedContext = {}) {
+        const { id, promotion_ids: promotionIds = [] } = data;
+        await this.campaignService_.retrieve(id, {}, sharedContext);
+        const promotionsToRemove = await this.promotionService_.list({ id: promotionIds }, {}, sharedContext);
+        const diff = (0, utils_1.arrayDifference)(promotionsToRemove.map((p) => p.id), promotionIds);
+        if (diff.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Promotions with ids (${diff.join(",")}) not found.`);
+        }
+        await this.promotionService_.update(promotionsToRemove.map((promotion) => ({
+            id: promotion.id,
+            campaign_id: null,
+        })), sharedContext);
+        return promotionsToRemove.map((promo) => promo.id);
+    }
 }
 exports.default = PromotionModuleService;
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "registerUsage", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "revertUsage", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
     __param(3, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "computeActions", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "create", null);
+], PromotionModuleService.prototype, "createPromotions", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "create_", null);
+], PromotionModuleService.prototype, "createPromotions_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "update", null);
+], PromotionModuleService.prototype, "updatePromotions", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "update_", null);
+], PromotionModuleService.prototype, "updatePromotions_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)()
+    // @ts-ignore
+    ,
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updatePromotionRules", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updatePromotionRules_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "addPromotionRules", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "addPromotionTargetRules", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "addPromotionBuyRules", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(3, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, String, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "createPromotionRulesAndValues_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removePromotionRules", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removePromotionRules_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removePromotionTargetRules", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removePromotionBuyRules", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(3, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Array, String, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "removeApplicationMethodRules_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "createCampaigns", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "createCampaigns_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updateCampaigns", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updateCampaigns_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "addPromotionsToCampaign", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "addPromotionsToCampaign_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "removePromotionsFromCampaign", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PromotionModuleService.prototype, "removePromotionsFromCampaign_", null);
+//# sourceMappingURL=promotion-module.js.map