@medusajs/promotion 0.0.5-snapshot-20240916110643 → 0.0.6

package/dist/services/promotion-module.js

@@ -18,14 +18,14 @@ const _models_1 = require("../models");
 const _types_1 = require("../types");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
-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,
-}) {
+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) {
     constructor({ baseRepository, promotionService, applicationMethodService, promotionRuleService, promotionRuleValueService, campaignService, campaignBudgetService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
@@ -45,19 +45,14 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         const promotionCodes = computedActions
             .map((computedAction) => computedAction.code)
             .filter(Boolean);
-        const campaignBudgetMap = new Map();
+        const promotionCodeCampaignBudgetMap = new Map();
         const promotionCodeUsageMap = new Map();
-        const existingPromotions = await this.listPromotions({ code: promotionCodes }, {
-            relations: ["campaign", "campaign.budget"],
-            take: null,
-        }, sharedContext);
-        for (const promotion of existingPromotions) {
-            if (promotion.campaign?.budget) {
-                campaignBudgetMap.set(promotion.campaign?.budget.id, promotion.campaign?.budget);
-            }
-        }
+        const existingPromotions = await this.list({ code: promotionCodes }, { relations: ["application_method", "campaign", "campaign.budget"] }, sharedContext);
         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;
@@ -67,16 +62,14 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 continue;
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.SPEND) {
-                const campaignBudgetData = campaignBudgetMap.get(campaignBudget.id);
-                if (!campaignBudgetData) {
-                    continue;
-                }
-                campaignBudgetData.used = utils_1.MathBN.add(campaignBudgetData.used ?? 0, computedAction.amount);
+                const campaignBudgetData = promotionCodeCampaignBudgetMap.get(campaignBudget.id) || { id: campaignBudget.id, used: campaignBudget.used ?? 0 };
+                campaignBudgetData.used =
+                    (campaignBudgetData.used ?? 0) + computedAction.amount;
                 if (campaignBudget.limit &&
-                    utils_1.MathBN.gt(campaignBudgetData.used, campaignBudget.limit)) {
+                    campaignBudgetData.used > campaignBudget.limit) {
                     continue;
                 }
-                campaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
+                promotionCodeCampaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
             }
             if (campaignBudget.type === utils_1.CampaignBudgetType.USAGE) {
                 const promotionAlreadyUsed = promotionCodeUsageMap.get(promotion.code) || false;
@@ -85,69 +78,17 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 }
                 const campaignBudgetData = {
                     id: campaignBudget.id,
-                    used: utils_1.MathBN.add(campaignBudget.used ?? 0, 1),
+                    used: (campaignBudget.used ?? 0) + 1,
                 };
                 if (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"],
-            take: null,
-        }, 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) {
+                    campaignBudgetData.used > campaignBudget.limit) {
                     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;
-                }
-                campaignBudgetMap.set(campaignBudget.id, {
-                    id: campaignBudget.id,
-                    used: utils_1.MathBN.sub(campaignBudget.used ?? 0, 1),
-                });
+                promotionCodeCampaignBudgetMap.set(campaignBudget.id, campaignBudgetData);
                 promotionCodeUsageMap.set(promotion.code, true);
             }
             const campaignBudgetsData = [];
-            for (const [_, campaignBudgetData] of campaignBudgetMap) {
+            for (const [_, campaignBudgetData] of promotionCodeCampaignBudgetMap) {
                 campaignBudgetsData.push(campaignBudgetData);
             }
             await this.campaignBudgetService_.update(campaignBudgetsData, sharedContext);
@@ -161,13 +102,9 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         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.listPromotions({ is_automatic: true }, { select: ["code"], take: null }, sharedContext);
+            : await this.list({ is_automatic: true }, { select: ["code"], take: null }, 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);
@@ -195,7 +132,7 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 }
             });
         });
-        const promotions = await this.listPromotions({
+        const promotions = await this.list({
             code: [
                 ...promotionCodesToApply,
                 ...appliedItemCodes,
@@ -246,12 +183,12 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
             if (!applicationMethod) {
                 continue;
             }
-            const isPromotionApplicable = (0, _utils_1.areRulesValidForContext)(promotionRules, applicationContext, utils_1.ApplicationMethodTargetType.ORDER);
+            const isPromotionApplicable = (0, _utils_1.areRulesValidForContext)(promotionRules, applicationContext);
             if (!isPromotionApplicable) {
                 continue;
             }
             if (promotion.type === utils_1.PromotionType.BUYGET) {
-                const computedActionsForItems = _utils_1.ComputeActionUtils.getComputedActionsForBuyGet(promotion, applicationContext[utils_1.ApplicationMethodTargetType.ITEMS], methodIdPromoValueMap, eligibleBuyItemMap, eligibleTargetItemMap);
+                const computedActionsForItems = _utils_1.ComputeActionUtils.getComputedActionsForBuyGet(promotion, applicationContext[utils_1.ApplicationMethodTargetType.ITEMS], methodIdPromoValueMap);
                 computedActions.push(...computedActionsForItems);
             }
             if (promotion.type === utils_1.PromotionType.STANDARD) {
@@ -272,13 +209,12 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
                 }
             }
         }
-        (0, utils_1.transformPropertiesToBigNumber)(computedActions, { include: ["amount"] });
         return computedActions;
     }
-    async createPromotions(data, sharedContext = {}) {
+    async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const createdPromotions = await this.createPromotions_(input, sharedContext);
-        const promotions = await this.listPromotions({ id: createdPromotions.map((p) => p.id) }, {
+        const createdPromotions = await this.create_(input, sharedContext);
+        const promotions = await this.list({ id: createdPromotions.map((p) => p.id) }, {
             relations: [
                 "application_method",
                 "application_method.target_rules",
@@ -294,45 +230,31 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }, sharedContext);
         return Array.isArray(data) ? promotions : promotions[0];
     }
-    async createPromotions_(data, sharedContext = {}) {
+    async create_(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) {
-            promotionCodeApplicationMethodDataMap.set(promotionData.code, applicationMethodData);
+            if (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_id: campaignId,
+                campaign: campaignId,
             });
         }
         const createdPromotions = await this.promotionService_.create(promotionsData, sharedContext);
@@ -375,14 +297,8 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
             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);
-        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);
+        if (campaignsData.length) {
+            await this.createCampaigns(campaignsData, sharedContext);
         }
         for (const applicationMethod of createdApplicationMethods) {
             await this.createPromotionRulesAndValues_(methodTargetRulesMap.get(applicationMethod.promotion.id) || [], "method_target_rules", applicationMethod, sharedContext);
@@ -390,10 +306,10 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }
         return createdPromotions;
     }
-    async updatePromotions(data, sharedContext = {}) {
+    async update(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const updatedPromotions = await this.updatePromotions_(input, sharedContext);
-        const promotions = await this.listPromotions({ id: updatedPromotions.map((p) => p.id) }, {
+        const updatedPromotions = await this.update_(input, sharedContext);
+        const promotions = await this.list({ id: updatedPromotions.map((p) => p.id) }, {
             relations: [
                 "application_method",
                 "application_method.target_rules",
@@ -407,34 +323,25 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }, sharedContext);
         return Array.isArray(data) ? promotions : promotions[0];
     }
-    async updatePromotions_(data, sharedContext = {}) {
+    async update_(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) {
-            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 });
+            if (campaignId) {
+                promotionsData.push({ ...promotionData, campaign: campaignId });
             }
             else {
                 promotionsData.push(promotionData);
             }
-            if (!applicationMethodData || !existingApplicationMethod) {
+            if (!applicationMethodData) {
+                continue;
+            }
+            const existingPromotion = existingPromotionsMap.get(promotionData.id);
+            const existingApplicationMethod = existingPromotion?.application_method;
+            if (!existingApplicationMethod) {
                 continue;
             }
             if (applicationMethodData.allocation &&
@@ -454,10 +361,9 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }
         return updatedPromotions;
     }
-    // @ts-ignore
     async updatePromotionRules(data, sharedContext = {}) {
         const updatedPromotionRules = await this.updatePromotionRules_(data, sharedContext);
-        return await this.listPromotionRules({ id: updatedPromotionRules.map((r) => r.id) }, { relations: ["values"] }, sharedContext);
+        return this.listPromotionRules({ id: updatedPromotionRules.map((r) => r.id) }, { relations: ["values"] }, sharedContext);
     }
     async updatePromotionRules_(data, sharedContext = {}) {
         const promotionRuleIds = data.map((d) => d.id);
@@ -507,7 +413,9 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         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"] }, sharedContext);
+        const promotion = await this.promotionService_.retrieve(promotionId, {
+            relations: ["application_method"],
+        });
         const applicationMethod = promotion.application_method;
         if (!applicationMethod) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `application_method for promotion not found`);
@@ -583,19 +491,22 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         const campaignBudgetsData = [];
         const campaignIdentifierBudgetMap = new Map();
         for (const createCampaignData of data) {
-            const { budget: campaignBudgetData, ...campaignData } = createCampaignData;
+            const { budget: campaignBudgetData, promotions, ...campaignData } = createCampaignData;
+            const promotionsToAdd = promotions
+                ? await this.list({ id: promotions.map((p) => p.id) }, { take: null }, sharedContext)
+                : [];
             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,
@@ -607,15 +518,6 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
         }
         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);
@@ -628,109 +530,36 @@ class PromotionModuleService extends (0, utils_1.MedusaService)({
     async updateCampaigns_(data, sharedContext = {}) {
         const campaignIds = data.map((d) => d.id);
         const campaignsData = [];
-        const updateBudgetData = [];
-        const createBudgetData = [];
+        const campaignBudgetsData = [];
         const existingCampaigns = await this.listCampaigns({ id: campaignIds }, { relations: ["budget"], take: null }, sharedContext);
         const existingCampaignsMap = new Map(existingCampaigns.map((campaign) => [campaign.id, campaign]));
         for (const updateCampaignData of data) {
-            const { budget: budgetData, ...campaignData } = updateCampaignData;
+            const { budget: campaignBudgetData, ...campaignData } = updateCampaignData;
             const existingCampaign = existingCampaignsMap.get(campaignData.id);
+            const existingCampaignBudget = existingCampaign?.budget;
             campaignsData.push(campaignData);
-            // 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,
-                    });
-                }
+            if (existingCampaignBudget && campaignBudgetData) {
+                campaignBudgetsData.push({
+                    id: existingCampaignBudget.id,
+                    ...campaignBudgetData,
+                });
             }
         }
         const updatedCampaigns = await this.campaignService_.update(campaignsData, sharedContext);
-        if (updateBudgetData.length) {
-            await this.campaignBudgetService_.update(updateBudgetData, sharedContext);
-        }
-        if (createBudgetData.length) {
-            await this.campaignBudgetService_.create(createBudgetData, sharedContext);
+        if (campaignBudgetsData.length) {
+            await this.campaignBudgetService_.update(campaignBudgetsData, 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 }, { take: 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 }, { take: null }, 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_"),
     __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_"),
-    __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)("baseRepository_"),
     __param(3, (0, utils_1.MedusaContext)()),
@@ -744,32 +573,30 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "createPromotions", null);
+], PromotionModuleService.prototype, "create", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "createPromotions_", null);
+], PromotionModuleService.prototype, "create_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "updatePromotions", null);
+], PromotionModuleService.prototype, "update", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "updatePromotions_", null);
+], PromotionModuleService.prototype, "update_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
+    (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
@@ -873,29 +700,3 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PromotionModuleService.prototype, "updateCampaigns_", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "addPromotionsToCampaign", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __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)("baseRepository_"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "removePromotionsFromCampaign", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], PromotionModuleService.prototype, "removePromotionsFromCampaign_", null);

package/dist/types/application-method.d.ts

@@ -1,26 +1,24 @@
-import { ApplicationMethodAllocationValues, ApplicationMethodTargetTypeValues, ApplicationMethodTypeValues, BigNumberInput, PromotionDTO } from "@medusajs/types";
+import { ApplicationMethodAllocationValues, ApplicationMethodTargetTypeValues, ApplicationMethodTypeValues, PromotionDTO } from "@medusajs/types";
 import { Promotion } from "../models";
 export interface CreateApplicationMethodDTO {
     type: ApplicationMethodTypeValues;
     target_type: ApplicationMethodTargetTypeValues;
     allocation?: ApplicationMethodAllocationValues;
-    value?: BigNumberInput;
-    currency_code?: string | null;
+    value?: number;
     promotion: Promotion | string | PromotionDTO;
-    max_quantity?: BigNumberInput | null;
-    buy_rules_min_quantity?: BigNumberInput | null;
-    apply_to_quantity?: BigNumberInput | null;
+    max_quantity?: number | null;
+    buy_rules_min_quantity?: number | null;
+    apply_to_quantity?: number | null;
 }
 export interface UpdateApplicationMethodDTO {
-    id?: string;
+    id: string;
     type?: ApplicationMethodTypeValues;
     target_type?: ApplicationMethodTargetTypeValues;
     allocation?: ApplicationMethodAllocationValues;
-    value?: BigNumberInput;
-    currency_code?: string | null;
+    value?: number;
     promotion?: Promotion | string | PromotionDTO;
-    max_quantity?: BigNumberInput | null;
-    buy_rules_min_quantity?: BigNumberInput | null;
-    apply_to_quantity?: BigNumberInput | null;
+    max_quantity?: number | null;
+    buy_rules_min_quantity?: number | null;
+    apply_to_quantity?: number | null;
 }
 //# sourceMappingURL=application-method.d.ts.map

package/dist/types/application-method.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"application-method.d.ts","sourceRoot":"","sources":["../../src/types/application-method.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,iCAAiC,EACjC,2BAA2B,EAC3B,cAAc,EACd,YAAY,EACb,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,2BAA2B,CAAA;IACjC,WAAW,EAAE,iCAAiC,CAAA;IAC9C,UAAU,CAAC,EAAE,iCAAiC,CAAA;IAC9C,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,YAAY,CAAA;IAC5C,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IACpC,sBAAsB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9C,iBAAiB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;CAC1C;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,IAAI,CAAC,EAAE,2BAA2B,CAAA;IAClC,WAAW,CAAC,EAAE,iCAAiC,CAAA;IAC/C,UAAU,CAAC,EAAE,iCAAiC,CAAA;IAC9C,KAAK,CAAC,EAAE,cAAc,CAAA;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,SAAS,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,YAAY,CAAA;IAC7C,YAAY,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IACpC,sBAAsB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IAC9C,iBAAiB,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;CAC1C"}
+{"version":3,"file":"application-method.d.ts","sourceRoot":"","sources":["../../src/types/application-method.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,iCAAiC,EACjC,2BAA2B,EAC3B,YAAY,EACb,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAEnC,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,2BAA2B,CAAA;IACjC,WAAW,EAAE,iCAAiC,CAAA;IAC9C,UAAU,CAAC,EAAE,iCAAiC,CAAA;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,SAAS,GAAG,MAAM,GAAG,YAAY,CAAA;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC;AAED,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,2BAA2B,CAAA;IAClC,WAAW,CAAC,EAAE,iCAAiC,CAAA;IAC/C,UAAU,CAAC,EAAE,iCAAiC,CAAA;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,SAAS,GAAG,MAAM,GAAG,YAAY,CAAA;IAC7C,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,sBAAsB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACtC,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAClC"}

package/dist/types/campaign-budget.d.ts

@@ -1,17 +1,15 @@
-import { BigNumberInput, CampaignBudgetTypeValues } from "@medusajs/types";
+import { CampaignBudgetTypeValues } from "@medusajs/types";
 import { Campaign } from "../models";
 export interface CreateCampaignBudgetDTO {
-    type?: CampaignBudgetTypeValues;
-    limit?: BigNumberInput | null;
-    currency_code?: string | null;
-    used?: BigNumberInput;
+    type: CampaignBudgetTypeValues;
+    limit: number | null;
+    used?: number;
     campaign?: Campaign | string;
 }
 export interface UpdateCampaignBudgetDTO {
     id: string;
     type?: CampaignBudgetTypeValues;
-    limit?: BigNumberInput | null;
-    currency_code?: string | null;
-    used?: BigNumberInput;
+    limit?: number | null;
+    used?: number;
 }
 //# sourceMappingURL=campaign-budget.d.ts.map

package/dist/types/campaign-budget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"campaign-budget.d.ts","sourceRoot":"","sources":["../../src/types/campaign-budget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,wBAAwB,CAAA;IAC/B,KAAK,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,CAAC,EAAE,cAAc,CAAA;IACrB,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,wBAAwB,CAAA;IAC/B,KAAK,CAAC,EAAE,cAAc,GAAG,IAAI,CAAA;IAC7B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,IAAI,CAAC,EAAE,cAAc,CAAA;CACtB"}
+{"version":3,"file":"campaign-budget.d.ts","sourceRoot":"","sources":["../../src/types/campaign-budget.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,iBAAiB,CAAA;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,wBAAwB,CAAA;IAC9B,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,QAAQ,CAAC,EAAE,QAAQ,GAAG,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,CAAC,EAAE,wBAAwB,CAAA;IAC/B,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd"}