@medusajs/pricing 2.11.0-snapshot-20250829134337 → 2.11.0-snapshot-20251014110210

package/dist/services/pricing-module.js

@@ -31,6 +31,7 @@ class PricingModuleService extends BaseClass {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
+        this.container_ = arguments[0];
         this.baseRepository_ = baseRepository;
         this.pricingRepository_ = pricingRepository;
         this.priceSetService_ = priceSetService;
@@ -115,7 +116,7 @@ class PricingModuleService extends BaseClass {
             const calculatedPrice = calculatedPricesMap.get(priceSet.id);
             priceSet.calculated_price = calculatedPrice ?? null;
         }
-        return priceSets;
+        return await this.baseRepository_.serialize(priceSets);
     }
     // @ts-expect-error
     async listAndCountPriceSets(filters = {}, config = {}, sharedContext = {}) {
@@ -123,7 +124,8 @@ class PricingModuleService extends BaseClass {
         const pricingContext = this.setupCalculatedPriceConfig_(filters, normalizedConfig);
         const [priceSets, count] = await super.listAndCountPriceSets(filters, normalizedConfig, sharedContext);
         if (!pricingContext || !priceSets.length) {
-            return [priceSets, count];
+            const serializedPriceSets = await this.baseRepository_.serialize(priceSets);
+            return [serializedPriceSets, count];
         }
         const calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
         const calculatedPricesMap = new Map();
@@ -134,7 +136,24 @@ class PricingModuleService extends BaseClass {
             const calculatedPrice = calculatedPricesMap.get(priceSet.id);
             priceSet.calculated_price = calculatedPrice ?? null;
         }
-        return [priceSets, count];
+        const serializedPriceSets = await this.baseRepository_.serialize(priceSets);
+        return [serializedPriceSets, count];
+    }
+    // @ts-expect-error
+    async listPriceRules(filters, config = {}, sharedContext) {
+        const priceRules = await this.listPriceRules_(filters, config, sharedContext);
+        return await this.baseRepository_.serialize(priceRules);
+    }
+    async listPriceRules_(filters, config = {}, sharedContext) {
+        return await this.priceRuleService_.list(filters, config, sharedContext);
+    }
+    // @ts-expect-error
+    async listPricePreferences(filters, config = {}, sharedContext) {
+        const pricePreferences = await this.listPricePreferences_(filters, { ...config, select: [...(config.select || []), "id"] }, sharedContext);
+        return await this.baseRepository_.serialize(pricePreferences);
+    }
+    async listPricePreferences_(filters, config = {}, sharedContext) {
+        return await this.pricePreferenceService_.list(filters, config, sharedContext);
     }
     async calculatePrices(pricingFilters, pricingContext = { context: {} }, sharedContext = {}) {
         const results = await this.pricingRepository_.calculatePrices(pricingFilters, pricingContext, sharedContext);
@@ -177,28 +196,33 @@ class PricingModuleService extends BaseClass {
             priceIds.push(...(0, utils_1.deduplicate)([calculatedPrice?.id, originalPrice?.id].filter(Boolean)));
         });
         // We use the price rules to get the right preferences for the price
-        const priceRulesForPrices = await this.priceRuleService_.list({ price_id: priceIds }, {});
+        const priceRulesForPrices = await this.listPriceRules({ price_id: priceIds }, {}, sharedContext);
         const priceRulesPriceMap = (0, utils_1.groupBy)(priceRulesForPrices, "price_id");
         // Note: For now the preferences are intentionally kept very simple and explicit - they use either the region or currency,
         // so we hard-code those as the possible filters here. This can be made more flexible if needed later on.
-        const pricingPreferences = await this.pricePreferenceService_.list({
-            $or: Object.entries(pricingContext)
-                .filter(([key, val]) => {
-                return key === "region_id" || key === "currency_code";
-            })
-                .map(([key, val]) => ({
-                attribute: key,
-                value: val,
-            })),
-        }, {}, sharedContext);
-        const calculatedPrices = pricingFilters.id
-            .map((priceSetId) => {
+        const preferenceContext = Object.entries(pricingContext.context ?? {}).filter(([key, val]) => {
+            return key === "region_id" || key === "currency_code";
+        });
+        let pricingPreferences = [];
+        if (preferenceContext.length) {
+            const preferenceFilters = preferenceContext.length
+                ? {
+                    $or: preferenceContext.map(([key, val]) => ({
+                        attribute: key,
+                        value: val,
+                    })),
+                }
+                : {};
+            pricingPreferences = await this.listPricePreferences_(preferenceFilters, {}, sharedContext);
+        }
+        const calculatedPrices = [];
+        for (const priceSetId of pricingFilters.id) {
             const prices = pricesSetPricesMap.get(priceSetId);
             if (!prices) {
-                return null;
+                continue;
             }
             const { calculatedPrice, originalPrice, } = prices;
-            return {
+            const calculatedPrice_ = {
                 id: priceSetId,
                 is_calculated_price_price_list: !!calculatedPrice?.price_list_id,
                 is_calculated_price_tax_inclusive: isTaxInclusive(priceRulesPriceMap.get(calculatedPrice.id), pricingPreferences, calculatedPrice.currency_code, pricingContext.context?.region_id),
@@ -230,9 +254,9 @@ class PricingModuleService extends BaseClass {
                     max_quantity: parseInt(originalPrice?.max_quantity || "") || null,
                 },
             };
-        })
-            .filter(Boolean);
-        return JSON.parse(JSON.stringify(calculatedPrices));
+            calculatedPrices.push(calculatedPrice_);
+        }
+        return calculatedPrices;
     }
     // @ts-expect-error
     async createPriceSets(data, sharedContext = {}) {
@@ -254,6 +278,15 @@ class PricingModuleService extends BaseClass {
         }
     }
     async upsertPriceSets(data, sharedContext = {}) {
+        const result = await this.upsertPriceSets_(data, sharedContext);
+        try {
+            return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
+    }
+    async upsertPriceSets_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((priceSet) => !!priceSet.id);
         const forCreate = input.filter((priceSet) => !priceSet.id);
@@ -265,12 +298,7 @@ class PricingModuleService extends BaseClass {
             operations.push(this.updatePriceSets_(forUpdate, sharedContext));
         }
         const result = (await (0, utils_1.promiseAll)(operations)).flat();
-        try {
-            return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
-        }
-        finally {
-            this.pricingRepository_.clearAvailableAttributes?.();
-        }
+        return result;
     }
     // @ts-expect-error
     async updatePriceSets(idOrSelector, data, sharedContext = {}) {
@@ -288,9 +316,9 @@ class PricingModuleService extends BaseClass {
             }));
         }
         const updateResult = await this.updatePriceSets_(normalizedInput, sharedContext);
-        const priceSets = await this.baseRepository_.serialize(updateResult);
+        const serializedUpdateResult = await this.baseRepository_.serialize((0, utils_1.isString)(idOrSelector) ? updateResult[0] : updateResult);
         try {
-            return (0, utils_1.isString)(idOrSelector) ? priceSets[0] : priceSets;
+            return serializedUpdateResult;
         }
         finally {
             this.pricingRepository_.clearAvailableAttributes?.();
@@ -345,24 +373,12 @@ class PricingModuleService extends BaseClass {
                             ...rule,
                             price_id: priceToUpdate.id,
                         })), sharedContext);
-                        _utils_1.eventBuilders.createdPriceRule({
-                            data: createdPriceRules.map((r) => ({ id: r.id })),
-                            sharedContext,
-                        });
                     }
                     if (priceRulesToUpdate.length > 0) {
                         updatedPriceRules = await this.priceRuleService_.update(priceRulesToUpdate, sharedContext);
-                        _utils_1.eventBuilders.updatedPriceRule({
-                            data: updatedPriceRules.map((r) => ({ id: r.id })),
-                            sharedContext,
-                        });
                     }
                     if (priceRulesToDelete.length > 0) {
                         await this.priceRuleService_.delete(priceRulesToDelete, sharedContext);
-                        _utils_1.eventBuilders.deletedPriceRule({
-                            data: priceRulesToDelete.map((id) => ({ id })),
-                            sharedContext,
-                        });
                     }
                     const upsertedPriceRules = [
                         ...createdPriceRules,
@@ -379,10 +395,6 @@ class PricingModuleService extends BaseClass {
                     const priceRuleToDelete = existingPrice?.price_rules?.map((r) => r.id);
                     if (priceRuleToDelete?.length) {
                         await this.priceRuleService_.delete(priceRuleToDelete, sharedContext);
-                        _utils_1.eventBuilders.deletedPriceRule({
-                            data: priceRuleToDelete.map((id) => ({ id })),
-                            sharedContext,
-                        });
                     }
                     ;
                     priceToUpdate.rules_count = 0;
@@ -399,24 +411,6 @@ class PricingModuleService extends BaseClass {
         if (pricesToDelete.length > 0) {
             await this.priceService_.delete(pricesToDelete, sharedContext);
         }
-        if (createdPrices.length > 0) {
-            _utils_1.eventBuilders.createdPrice({
-                data: createdPrices.map((p) => ({ id: p.id })),
-                sharedContext,
-            });
-        }
-        if (updatedPrices.length > 0) {
-            _utils_1.eventBuilders.updatedPrice({
-                data: updatedPrices.map((p) => ({ id: p.id })),
-                sharedContext,
-            });
-        }
-        if (pricesToDelete.length > 0) {
-            _utils_1.eventBuilders.deletedPrice({
-                data: pricesToDelete.map((id) => ({ id })),
-                sharedContext,
-            });
-        }
         const priceSets = await this.priceSetService_.list({ id: normalizedData.map(({ id }) => id) }, {
             relations: ["prices", "prices.price_rules"],
         }, sharedContext);
@@ -432,10 +426,6 @@ class PricingModuleService extends BaseClass {
         priceSets.forEach((ps) => {
             ps.prices = upsertedPricesMap.get(ps.id) || [];
         });
-        _utils_1.eventBuilders.updatedPriceSet({
-            data: priceSets.map((ps) => ({ id: ps.id })),
-            sharedContext,
-        });
         return priceSets;
     }
     async normalizeUpdateData(data) {
@@ -468,7 +458,8 @@ class PricingModuleService extends BaseClass {
                         return {
                             attribute,
                             operator: customRule.operator,
-                            value: customRule.value,
+                            // TODO: we throw above if value is not a number, but the model expect the value to be a string
+                            value: customRule.value.toString(),
                         };
                     });
                 }
@@ -505,8 +496,9 @@ class PricingModuleService extends BaseClass {
         const orderedPriceSets = input.map((inputItem) => {
             return dbPrices.find((p) => p.id === inputItem.priceSetId);
         });
+        const serializedOrderedPriceSets = await this.baseRepository_.serialize(Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0]);
         try {
-            return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0];
+            return serializedOrderedPriceSets;
         }
         finally {
             this.pricingRepository_.clearAvailableAttributes?.();
@@ -578,6 +570,10 @@ class PricingModuleService extends BaseClass {
         return Array.isArray(data) ? serialized : serialized[0];
     }
     async upsertPricePreferences(data, sharedContext = {}) {
+        const result = await this.upsertPricePreferences_(data, sharedContext);
+        return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
+    }
+    async upsertPricePreferences_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((pricePreference) => !!pricePreference.id);
         const forCreate = input.filter((pricePreference) => !pricePreference.id);
@@ -589,7 +585,7 @@ class PricingModuleService extends BaseClass {
             operations.push(this.updatePricePreferences_(forUpdate, sharedContext));
         }
         const result = (await (0, utils_1.promiseAll)(operations)).flat();
-        return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
+        return result;
     }
     // @ts-expect-error
     async updatePricePreferences(idOrSelector, data, sharedContext = {}) {
@@ -632,38 +628,6 @@ class PricingModuleService extends BaseClass {
         });
         // Bulk create price sets
         const priceSets = await this.priceSetService_.create(toCreate, sharedContext);
-        const eventsData = priceSets.reduce((eventsData, priceSet) => {
-            eventsData.priceSets.push({
-                id: priceSet.id,
-            });
-            priceSet.prices.map((price) => {
-                eventsData.prices.push({
-                    id: price.id,
-                });
-                price.price_rules.map((priceRule) => {
-                    eventsData.priceRules.push({
-                        id: priceRule.id,
-                    });
-                });
-            });
-            return eventsData;
-        }, {
-            priceSets: [],
-            priceRules: [],
-            prices: [],
-        });
-        _utils_1.eventBuilders.createdPriceSet({
-            data: eventsData.priceSets,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdPrice({
-            data: eventsData.prices,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdPriceRule({
-            data: eventsData.priceRules,
-            sharedContext,
-        });
         return priceSets;
     }
     async addPrices_(input, sharedContext = {}) {
@@ -685,12 +649,7 @@ class PricingModuleService extends BaseClass {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price set with id: ${price.price_set_id} not found`);
             }
         });
-        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
+        const { entities } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
         return entities;
     }
     async createPriceLists_(data, sharedContext = {}) {
@@ -723,54 +682,6 @@ class PricingModuleService extends BaseClass {
             return entry;
         });
         const priceLists = await this.priceListService_.create(priceListsToCreate, sharedContext);
-        /**
-         * Preparing data for emitting events
-         */
-        const eventsData = priceLists.reduce((eventsData, priceList) => {
-            eventsData.priceList.push({
-                id: priceList.id,
-            });
-            priceList.price_list_rules.map((listRule) => {
-                eventsData.priceListRules.push({
-                    id: listRule.id,
-                });
-            });
-            priceList.prices.map((price) => {
-                eventsData.prices.push({
-                    id: price.id,
-                });
-                price.price_rules.map((priceRule) => {
-                    eventsData.priceRules.push({
-                        id: priceRule.id,
-                    });
-                });
-            });
-            return eventsData;
-        }, {
-            priceList: [],
-            priceListRules: [],
-            priceRules: [],
-            prices: [],
-        });
-        /**
-         * Emitting events for all created entities
-         */
-        _utils_1.eventBuilders.createdPriceList({
-            data: eventsData.priceList,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdPriceListRule({
-            data: eventsData.priceListRules,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdPrice({
-            data: eventsData.prices,
-            sharedContext,
-        });
-        _utils_1.eventBuilders.createdPriceRule({
-            data: eventsData.priceRules,
-            sharedContext,
-        });
         return priceLists;
     }
     async updatePriceLists_(data, sharedContext = {}) {
@@ -804,14 +715,9 @@ class PricingModuleService extends BaseClass {
             }
             return entry;
         });
-        const { entities, performedActions } = await this.priceListService_.upsertWithReplace(normalizedData, {
+        const { entities } = await this.priceListService_.upsertWithReplace(normalizedData, {
             relations: ["price_list_rules"],
         });
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
         return entities;
     }
     async updatePriceListPrices_(data, sharedContext = {}) {
@@ -830,12 +736,7 @@ class PricingModuleService extends BaseClass {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
         }
-        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
+        const { entities } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
         return entities;
     }
     async removePrices_(ids, sharedContext = {}) {
@@ -857,12 +758,7 @@ class PricingModuleService extends BaseClass {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${price.price_list_id} not found`);
             }
         });
-        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
+        const { entities } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
         return entities;
     }
     async setPriceListRules_(data, sharedContext = {}) {
@@ -900,12 +796,7 @@ class PricingModuleService extends BaseClass {
             };
         })
             .filter(Boolean);
-        const { entities, performedActions } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
+        const { entities } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
         return entities;
     }
     async removePriceListRules_(data, sharedContext = {}) {
@@ -945,12 +836,7 @@ class PricingModuleService extends BaseClass {
             };
         })
             .filter(Boolean);
-        const { entities, performedActions } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
+        const { entities } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
         return entities;
     }
     normalizePriceListDate(data) {
@@ -975,6 +861,42 @@ class PricingModuleService extends BaseClass {
     }
 }
 exports.default = PricingModuleService;
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "createPriceRules", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "updatePriceRules", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "createPriceListRules", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.EmitEvents)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "updatePriceListRules", null);
 __decorate([
     (0, utils_1.InjectManager)()
     // @ts-expect-error
@@ -1001,6 +923,22 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "listAndCountPriceSets", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "listPriceRules", null);
+__decorate([
+    (0, utils_1.InjectManager)()
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "listPricePreferences", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1026,6 +964,13 @@ __decorate([
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "upsertPriceSets", 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)
+], PricingModuleService.prototype, "upsertPriceSets_", null);
 __decorate([
     (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
@@ -1062,7 +1007,7 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "createPriceLists", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)(),
+    (0, utils_1.InjectManager)(),
     (0, utils_1.EmitEvents)()
     // @ts-ignore
     ,
@@ -1128,7 +1073,15 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "upsertPricePreferences", null);
 __decorate([
-    (0, utils_1.InjectManager)()
+    (0, utils_1.InjectTransactionManager)(),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "upsertPricePreferences_", null);
+__decorate([
+    (0, utils_1.InjectManager)(),
+    (0, utils_1.EmitEvents)()
     // @ts-expect-error
     ,
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1208,20 +1161,6 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "removePriceListRules_", null);
-const composeAllEvents = ({ eventBuilders, performedActions, sharedContext, }) => {
-    for (const action of Object.keys(performedActions)) {
-        for (const entity of Object.keys(performedActions[action])) {
-            const eventName = action + (0, utils_1.upperCaseFirst)(entity);
-            if (!eventBuilders[eventName]) {
-                continue;
-            }
-            eventBuilders[eventName]({
-                data: performedActions[action][entity] ?? [],
-                sharedContext,
-            });
-        }
-    }
-};
 const isTaxInclusive = (priceRules, preferences, currencyCode, regionId) => {
     const regionRule = priceRules?.find((rule) => rule.attribute === "region_id" && rule.value === regionId);
     const regionPreference = preferences.find((p) => p.attribute === "region_id" && p.value === regionId);