@medusajs/pricing 3.0.0-snapshot-20250410112222 → 3.0.0-snapshot-20251104004624

package/dist/services/pricing-module.js

@@ -25,11 +25,13 @@ const generateMethodForModels = {
     Price: _models_1.Price,
     PricePreference: _models_1.PricePreference,
 };
-class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
+const BaseClass = utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels);
+class PricingModuleService extends BaseClass {
     constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, pricePreferenceService, priceListService, priceListRuleService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
+        this.container_ = arguments[0];
         this.baseRepository_ = baseRepository;
         this.pricingRepository_ = pricingRepository;
         this.priceSetService_ = priceSetService;
@@ -55,6 +57,44 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return pricingContext;
     }
     // @ts-expect-error
+    async createPriceRules(...args) {
+        try {
+            return await super.createPriceRules(...args);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
+    }
+    // @ts-expect-error
+    async updatePriceRules(...args) {
+        try {
+            return await super.updatePriceRules(...args);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
+    }
+    // @ts-expect-error
+    async createPriceListRules(...args) {
+        try {
+            // @ts-ignore
+            return await super.createPriceListRules(...args);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
+    }
+    // @ts-expect-error
+    async updatePriceListRules(...args) {
+        try {
+            // @ts-ignore
+            return await super.updatePriceListRules(...args);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
+    }
+    // @ts-expect-error
     async retrievePriceSet(id, config, sharedContext) {
         const priceSet = await this.priceSetService_.retrieve(id, this.normalizePriceSetConfig(config), sharedContext);
         return await this.baseRepository_.serialize(priceSet);
@@ -76,7 +116,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             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 = {}) {
@@ -84,7 +124,8 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         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();
@@ -95,7 +136,24 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             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, 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);
@@ -113,6 +171,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             /**
              * When deciding which price to use we follow the following logic:
              * - If the price list is of type OVERRIDE, we always use the price list price.
+             *   - If there are multiple price list prices of type OVERRIDE, we use the one with the lowest amount.
              * - If the price list is of type SALE, we use the lowest price between the price list price and the default price
              */
             if (priceListPrice) {
@@ -137,28 +196,33 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             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),
@@ -190,9 +254,9 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                     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 = {}) {
@@ -206,9 +270,23 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const results = priceSets.map((priceSet) => {
             return dbPriceSets.find((p) => p.id === priceSet.id);
         });
-        return await this.baseRepository_.serialize(Array.isArray(data) ? results : results[0]);
+        try {
+            return await this.baseRepository_.serialize(Array.isArray(data) ? results : results[0]);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     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);
@@ -220,7 +298,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             operations.push(this.updatePriceSets_(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 updatePriceSets(idOrSelector, data, sharedContext = {}) {
@@ -238,59 +316,117 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             }));
         }
         const updateResult = await this.updatePriceSets_(normalizedInput, sharedContext);
-        const priceSets = await this.baseRepository_.serialize(updateResult);
-        return (0, utils_1.isString)(idOrSelector) ? priceSets[0] : priceSets;
+        const serializedUpdateResult = await this.baseRepository_.serialize((0, utils_1.isString)(idOrSelector) ? updateResult[0] : updateResult);
+        try {
+            return serializedUpdateResult;
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async updatePriceSets_(data, sharedContext = {}) {
-        // TODO: Since money IDs are rarely passed, this will delete all previous data and insert new entries.
-        // We can make the `insert` inside upsertWithReplace do an `upsert` instead to avoid this
         const normalizedData = await this.normalizeUpdateData(data);
-        const priceListPrices = await this.priceService_.list({
-            price_set_id: normalizedData.map(({ id }) => id),
-            price_list_id: { $ne: null },
-        });
+        const priceSetIds = normalizedData.map(({ id }) => id);
+        const existingPrices = await this.priceService_.list({
+            price_set_id: priceSetIds,
+            price_list_id: null,
+        }, {
+            relations: ["price_rules"],
+            take: null,
+        }, sharedContext);
+        const existingPricesMap = new Map(existingPrices.map((p) => [p.id, p]));
         const prices = normalizedData.flatMap((priceSet) => priceSet.prices || []);
-        const { entities: upsertedPrices, performedActions } = await this.priceService_.upsertWithReplace(prices, { relations: ["price_rules"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions,
-            sharedContext,
-        });
-        const priceSetsToUpsert = normalizedData.map((priceSet) => {
-            const { prices, ...rest } = priceSet;
-            return {
-                ...rest,
-                prices: [
-                    ...upsertedPrices
-                        .filter((p) => p.price_set_id === priceSet.id)
-                        .map((price) => {
-                        // @ts-ignore
-                        delete price.price_rules;
-                        return price;
-                    }),
-                    ...priceListPrices
-                        .filter((p) => p.price_set_id === priceSet.id)
-                        .map((price) => ({
-                        id: price.id,
-                        amount: price.amount,
-                        price_set_id: price.price_set_id,
-                        price_list_id: price.price_list_id,
-                    })),
-                ],
-            };
-        });
-        const { entities: priceSets, performedActions: priceSetPerformedActions } = await this.priceSetService_.upsertWithReplace(priceSetsToUpsert, { relations: ["prices"] }, sharedContext);
-        composeAllEvents({
-            eventBuilders: _utils_1.eventBuilders,
-            performedActions: priceSetPerformedActions,
-            sharedContext,
-        });
-        return priceSets.map((ps) => {
-            if (ps.prices) {
-                ps.prices = ps.prices.filter((p) => !p.price_list_id);
+        const pricesToCreate = prices.filter((price) => !price.id || !existingPricesMap.has(price.id));
+        const pricesToUpdate = prices.filter((price) => price.id && existingPricesMap.has(price.id));
+        const incomingPriceIds = new Set(prices.map((p) => p.id).filter(Boolean));
+        const pricesToDelete = existingPrices
+            .filter((existingPrice) => !incomingPriceIds.has(existingPrice.id))
+            .map((p) => p.id);
+        let createdPrices = [];
+        let updatedPrices = [];
+        if (pricesToCreate.length > 0) {
+            createdPrices = await this.priceService_.create(pricesToCreate.map((price) => {
+                price.price_rules ??= [];
+                return price;
+            }), sharedContext);
+        }
+        if (pricesToUpdate.length > 0) {
+            // Handle price rules for updated prices
+            for (const priceToUpdate of pricesToUpdate) {
+                const existingPrice = existingPricesMap.get(priceToUpdate.id);
+                if (priceToUpdate.price_rules?.length) {
+                    const existingPriceRules = existingPrice?.price_rules || [];
+                    // Separate price rules for create, update, delete
+                    const priceRulesToCreate = priceToUpdate.price_rules.filter((rule) => !("id" in rule));
+                    const priceRulesToUpdate = priceToUpdate.price_rules.filter((rule) => "id" in rule);
+                    const incomingPriceRuleIds = new Set(priceToUpdate.price_rules
+                        .map((r) => "id" in r && r.id)
+                        .filter(Boolean));
+                    const priceRulesToDelete = existingPriceRules
+                        .filter((existingRule) => !incomingPriceRuleIds.has(existingRule.id))
+                        .map((r) => r.id);
+                    let createdPriceRules = [];
+                    let updatedPriceRules = [];
+                    // Bulk operations for price rules
+                    if (priceRulesToCreate.length > 0) {
+                        createdPriceRules = await this.priceRuleService_.create(priceRulesToCreate.map((rule) => ({
+                            ...rule,
+                            price_id: priceToUpdate.id,
+                        })), sharedContext);
+                    }
+                    if (priceRulesToUpdate.length > 0) {
+                        updatedPriceRules = await this.priceRuleService_.update(priceRulesToUpdate, sharedContext);
+                    }
+                    if (priceRulesToDelete.length > 0) {
+                        await this.priceRuleService_.delete(priceRulesToDelete, sharedContext);
+                    }
+                    const upsertedPriceRules = [
+                        ...createdPriceRules,
+                        ...updatedPriceRules,
+                    ];
+                    priceToUpdate.price_rules = upsertedPriceRules;
+                    priceToUpdate.rules_count =
+                        upsertedPriceRules.length;
+                }
+                else if (
+                // In the case price_rules is provided but without any rules, we delete the existing rules
+                (0, utils_1.isDefined)(priceToUpdate.price_rules) &&
+                    priceToUpdate.price_rules.length === 0) {
+                    const priceRuleToDelete = existingPrice?.price_rules?.map((r) => r.id);
+                    if (priceRuleToDelete?.length) {
+                        await this.priceRuleService_.delete(priceRuleToDelete, sharedContext);
+                    }
+                    ;
+                    priceToUpdate.rules_count = 0;
+                }
+                else {
+                    // @ts-expect-error - we want to delete the rules_count property in any case even if provided by mistake
+                    delete priceToUpdate.rules_count;
+                }
+                // We don't want to persist the price_rules in the database through the price service as it would not work
+                delete priceToUpdate.price_rules;
             }
-            return ps;
+            updatedPrices = await this.priceService_.update(pricesToUpdate, sharedContext);
+        }
+        if (pricesToDelete.length > 0) {
+            await this.priceService_.delete(pricesToDelete, sharedContext);
+        }
+        const priceSets = await this.priceSetService_.list({ id: normalizedData.map(({ id }) => id) }, {
+            relations: ["prices", "prices.price_rules"],
+        }, sharedContext);
+        const upsertedPricesMap = new Map();
+        const upsertedPrices = [...createdPrices, ...updatedPrices];
+        upsertedPrices.forEach((price) => {
+            upsertedPricesMap.set(price.price_set_id, [
+                ...(upsertedPricesMap.get(price.price_set_id) || []),
+                price,
+            ]);
         });
+        // re assign the prices to the price sets to not have to refetch after the transaction and keep the bahaviour the same as expected. If the user needs more data, he can still re list the price set with the expected fields and relations that he needs
+        priceSets.forEach((ps) => {
+            ps.prices = upsertedPricesMap.get(ps.id) || [];
+        });
+        return priceSets;
     }
     async normalizeUpdateData(data) {
         return data.map((priceSet) => {
@@ -303,18 +439,19 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     normalizePrices(data, existingPrices, priceListId) {
         const pricesToUpsert = new Map();
         const existingPricesMap = new Map();
-        existingPrices?.forEach((price) => {
+        Array.from(existingPrices ?? []).forEach((price) => {
             existingPricesMap.set(hashPrice(price), price);
         });
+        const ruleOperatorsSet = new Set(Object.values(utils_1.PricingRuleOperator));
+        const validOperatorsList = Array.from(ruleOperatorsSet).join(", ");
+        const invalidOperatorError = `operator should be one of ${validOperatorsList}`;
         data?.forEach((price) => {
             const cleanRules = price.rules ? (0, utils_1.removeNullish)(price.rules) : {};
-            const ruleOperators = Object.values(utils_1.PricingRuleOperator);
-            const rules = Object.entries(cleanRules)
-                .map(([attribute, value]) => {
+            const rules = Object.entries(cleanRules).flatMap(([attribute, value]) => {
                 if (Array.isArray(value)) {
                     return value.map((customRule) => {
-                        if (!ruleOperators.includes(customRule.operator)) {
-                            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `operator should be one of ${ruleOperators.join(", ")}`);
+                        if (!ruleOperatorsSet.has(customRule.operator)) {
+                            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, invalidOperatorError);
                         }
                         if (typeof customRule.value !== "number") {
                             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `value should be a number`);
@@ -322,7 +459,8 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                         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(),
                         };
                     });
                 }
@@ -330,25 +468,23 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                     attribute,
                     value,
                 };
-            })
-                .flat(1);
+            });
+            const entry = price;
             const hasRulesInput = (0, utils_1.isPresent)(price.rules);
-            const entry = {
-                ...price,
-                price_list_id: priceListId,
-                price_rules: hasRulesInput ? rules : undefined,
-                rules_count: hasRulesInput ? rules.length : undefined,
-            };
-            delete entry.rules;
+            entry.price_list_id = priceListId;
+            if (hasRulesInput) {
+                entry.price_rules = rules;
+                entry.rules_count = rules.length;
+                delete entry.rules;
+            }
             const entryHash = hashPrice(entry);
             // We want to keep the existing rules as they might already have ids, but any other data should come from the updated input
             const existing = existingPricesMap.get(entryHash);
-            pricesToUpsert.set(entryHash, {
-                ...entry,
-                id: existing?.id ?? entry.id,
-                price_rules: existing?.price_rules ?? entry.price_rules,
-            });
-            return entry;
+            if (existing) {
+                entry.id = existing.id ?? entry.id;
+                entry.price_rules = existing.price_rules ?? entry.price_rules;
+            }
+            pricesToUpsert.set(entryHash, entry);
         });
         return Array.from(pricesToUpsert.values());
     }
@@ -359,32 +495,68 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const orderedPriceSets = input.map((inputItem) => {
             return dbPrices.find((p) => p.id === inputItem.priceSetId);
         });
-        return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0];
+        const serializedOrderedPriceSets = await this.baseRepository_.serialize(Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0]);
+        try {
+            return serializedOrderedPriceSets;
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     // @ts-ignore
     async createPriceLists(data, sharedContext = {}) {
         const priceLists = await this.createPriceLists_(data, sharedContext);
-        return await this.baseRepository_.serialize(priceLists);
+        try {
+            return await this.baseRepository_.serialize(priceLists);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     // @ts-ignore
     async updatePriceLists(data, sharedContext = {}) {
         const priceLists = await this.updatePriceLists_(data, sharedContext);
-        return await this.baseRepository_.serialize(priceLists);
+        try {
+            return await this.baseRepository_.serialize(priceLists);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async updatePriceListPrices(data, sharedContext = {}) {
         const prices = await this.updatePriceListPrices_(data, sharedContext);
-        return await this.baseRepository_.serialize(prices);
+        try {
+            return await this.baseRepository_.serialize(prices);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async removePrices(ids, sharedContext = {}) {
-        await this.removePrices_(ids, sharedContext);
+        try {
+            await this.removePrices_(ids, sharedContext);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async addPriceListPrices(data, sharedContext = {}) {
         const prices = await this.addPriceListPrices_(data, sharedContext);
-        return await this.baseRepository_.serialize(prices);
+        try {
+            return await this.baseRepository_.serialize(prices);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async setPriceListRules(data, sharedContext = {}) {
         const [priceList] = await this.setPriceListRules_([data], sharedContext);
-        return await this.baseRepository_.serialize(priceList);
+        try {
+            return await this.baseRepository_.serialize(priceList);
+        }
+        finally {
+            this.pricingRepository_.clearAvailableAttributes?.();
+        }
     }
     async removePriceListRules(data, sharedContext = {}) {
         const [priceList] = await this.removePriceListRules_([data], sharedContext);
@@ -397,6 +569,10 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         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);
@@ -408,7 +584,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             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 = {}) {
@@ -451,52 +627,25 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         });
         // 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 = {}) {
-        const priceSets = await this.listPriceSets({ id: input.map((d) => d.priceSetId) }, { relations: ["prices", "prices.price_rules"] }, sharedContext);
-        const existingPrices = priceSets
-            .map((p) => p.prices)
-            .flat();
+        const prices = input.flatMap((data) => {
+            return data.prices.map((price) => {
+                ;
+                price.price_set_id = data.priceSetId;
+                return price;
+            });
+        });
+        const priceConstraints = buildPreNormalizationPriceConstraintsFromData(prices);
+        const [priceSets, priceSetPrices] = await (0, utils_1.promiseAll)([
+            this.listPriceSets({ id: input.map((d) => d.priceSetId) }, {}, sharedContext),
+            this.priceService_.list(priceConstraints, { relations: ["price_rules"] }, sharedContext),
+        ]);
+        const existingPrices = priceSetPrices;
         const pricesToUpsert = input
-            .map((addPrice) => this.normalizePrices(addPrice.prices?.map((p) => ({
-            ...p,
-            price_set_id: addPrice.priceSetId,
-        })), existingPrices))
-            .filter(Boolean)
-            .flat();
+            .flatMap((addPrice) => this.normalizePrices(addPrice.prices, existingPrices))
+            .filter(Boolean);
         const priceSetMap = new Map(priceSets.map((p) => [p.id, p]));
         pricesToUpsert.forEach((price) => {
             const priceSet = priceSetMap.get(price.price_set_id);
@@ -504,12 +653,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 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 = {}) {
@@ -542,54 +686,6 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             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 = {}) {
@@ -623,25 +719,23 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             }
             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 = {}) {
-        const priceLists = await this.listPriceLists({ id: data.map((p) => p.price_list_id) }, { relations: ["prices", "prices.price_rules"] }, sharedContext);
-        const existingPrices = priceLists
-            .map((p) => p.prices ?? [])
-            .flat();
+        const priceListIds = data.map((p) => p.price_list_id);
+        const prices = data.flatMap((p) => p.prices);
+        const priceConstraints = buildPreNormalizationPriceConstraintsFromData(prices, priceListIds);
+        const [priceLists, priceListPrices] = await (0, utils_1.promiseAll)([
+            this.priceListService_.list({ id: priceListIds }, {}, sharedContext),
+            this.priceService_.list(priceConstraints, { relations: ["price_rules"] }, sharedContext),
+        ]);
+        const existingPrices = priceListPrices;
         const pricesToUpsert = data
-            .map((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
-            .filter(Boolean)
-            .flat();
+            .flatMap((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
+            .filter(Boolean);
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
         for (const { price_list_id: priceListId } of data) {
             const priceList = priceListMap.get(priceListId);
@@ -649,26 +743,24 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 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 = {}) {
         await this.priceService_.delete(ids, sharedContext);
     }
     async addPriceListPrices_(data, sharedContext = {}) {
-        const priceLists = await this.listPriceLists({ id: data.map((p) => p.price_list_id) }, { relations: ["prices", "prices.price_rules"] }, sharedContext);
-        const existingPrices = priceLists
-            .map((p) => p.prices ?? [])
-            .flat();
+        const priceListIds = data.map((p) => p.price_list_id);
+        const prices = data.flatMap((p) => p.prices);
+        const priceConstraints = buildPreNormalizationPriceConstraintsFromData(prices, priceListIds);
+        const [priceLists, priceListPrices] = await (0, utils_1.promiseAll)([
+            this.priceListService_.list({ id: priceListIds }, {}, sharedContext),
+            this.priceService_.list(priceConstraints, { relations: ["price_rules"] }, sharedContext),
+        ]);
+        const existingPrices = priceListPrices;
         const pricesToUpsert = data
-            .map((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
-            .filter(Boolean)
-            .flat();
+            .flatMap((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
+            .filter(Boolean);
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
         pricesToUpsert.forEach((price) => {
             const priceList = priceListMap.get(price.price_list_id);
@@ -676,12 +768,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 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 = {}) {
@@ -719,12 +806,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             };
         })
             .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 = {}) {
@@ -764,12 +846,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             };
         })
             .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) {
@@ -794,6 +871,42 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     }
 }
 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
@@ -820,6 +933,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)()),
@@ -845,6 +974,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)()
@@ -881,7 +1017,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
     ,
@@ -947,7 +1083,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)()),
@@ -1027,20 +1171,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);
@@ -1054,19 +1184,97 @@ const isTaxInclusive = (priceRules, preferences, currencyCode, regionId) => {
     return false;
 };
 const hashPrice = (price) => {
-    const data = Object.entries({
-        currency_code: price.currency_code,
-        price_set_id: "price_set_id" in price ? price.price_set_id ?? null : null,
-        price_list_id: "price_list_id" in price ? price.price_list_id ?? null : null,
-        min_quantity: price.min_quantity ? price.min_quantity.toString() : null,
-        max_quantity: price.max_quantity ? price.max_quantity.toString() : null,
-        ...("price_rules" in price
-            ? price.price_rules?.reduce((agg, pr) => {
-                agg[pr.attribute] = pr.value;
-                return agg;
-            }, {})
-            : {}),
-    }).sort(([a], [b]) => a.localeCompare(b));
-    return (0, utils_1.simpleHash)(JSON.stringify(data));
+    // Build hash using deterministic property order to avoid expensive sort operation
+    // Using a direct string concatenation approach for better performance
+    const parts = [];
+    if ("currency_code" in price) {
+        parts.push(`cc:${price.currency_code ?? ""}`);
+    }
+    if ("price_set_id" in price) {
+        parts.push(`ps:${price.price_set_id ?? ""}`);
+    }
+    if ("price_list_id" in price) {
+        parts.push(`pl:${price.price_list_id ?? ""}`);
+    }
+    if ("min_quantity" in price) {
+        parts.push(`min:${price.min_quantity ?? ""}`);
+    }
+    if ("max_quantity" in price) {
+        parts.push(`max:${price.max_quantity ?? ""}`);
+    }
+    // Add price rules in a deterministic way if present
+    if ("price_rules" in price && price.price_rules) {
+        const sortedRules = price.price_rules.map((pr) => `${pr.attribute}=${pr.value}`);
+        if (sortedRules.length) {
+            parts.push(`rules:${sortedRules.join(",")}`);
+        }
+    }
+    return parts.sort().join("|");
+};
+/**
+ * Build targeted database constraints to fetch only prices that could match the incoming data.
+ * Uses the same properties as hashPrice to ensure consistency.
+ */
+const buildPreNormalizationPriceConstraintsFromData = (prices, priceListIds) => {
+    // Separate prices with explicit IDs from those without
+    const pricesWithIds = prices.filter((p) => p.id).map((p) => p.id);
+    // Build unique constraints based on hash properties
+    const constraintSet = new Set();
+    const constraints = [];
+    for (const price of prices) {
+        // Skip if price has explicit ID (will be queried separately)
+        if (price.id)
+            continue;
+        const constraint = {};
+        if (price.currency_code !== undefined) {
+            constraint.currency_code = price.currency_code;
+        }
+        if ("price_set_id" in price && price.price_set_id !== undefined) {
+            constraint.price_set_id = price.price_set_id;
+        }
+        if ("price_list_id" in price && price.price_list_id !== undefined) {
+            constraint.price_list_id = price.price_list_id;
+        }
+        if (price.min_quantity !== undefined) {
+            constraint.min_quantity = price.min_quantity;
+        }
+        if (price.max_quantity !== undefined) {
+            constraint.max_quantity = price.max_quantity;
+        }
+        // Use hash to deduplicate constraints
+        const constraintHash = JSON.stringify(constraint);
+        if (!constraintSet.has(constraintHash)) {
+            constraintSet.add(constraintHash);
+            constraints.push(constraint);
+        }
+    }
+    // Build final query
+    const query = {};
+    if (priceListIds) {
+        if (Array.isArray(priceListIds) && priceListIds.length > 0) {
+            query.price_list_id = {
+                $in: priceListIds,
+            };
+        }
+        else {
+            query.price_list_id = priceListIds;
+        }
+    }
+    // Combine ID-based and property-based constraints
+    if (pricesWithIds.length && constraints.length) {
+        query.$or = [{ id: pricesWithIds }, ...constraints];
+    }
+    else if (pricesWithIds.length) {
+        query.id = pricesWithIds;
+    }
+    else if (constraints.length) {
+        if (constraints.length === 1) {
+            Object.assign(query, constraints[0]);
+        }
+        else {
+            query.$or = constraints;
+        }
+    }
+    return query;
 };
 //# sourceMappingURL=pricing-module.js.map