@medusajs/pricing 0.1.13-snapshot-20240701122250 → 0.1.13-snapshot-20240704061641

package/dist/joiner-config.d.ts

@@ -1,3 +1 @@
-import { MapToConfig } from "@medusajs/utils";
 export declare const joinerConfig: Omit<import("@medusajs/types").ModuleJoinerConfig, "serviceName" | "primaryKeys" | "alias" | "linkableKeys"> & Required<Pick<import("@medusajs/types").ModuleJoinerConfig, "serviceName" | "primaryKeys" | "alias" | "linkableKeys">>;
-export declare const entityNameToLinkableKeysMap: MapToConfig;

package/dist/joiner-config.js

@@ -1,14 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.entityNameToLinkableKeysMap = exports.joinerConfig = void 0;
+exports.joinerConfig = void 0;
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("./models");
 exports.joinerConfig = (0, utils_1.defineJoinerConfig)(utils_1.Modules.PRICING, {
-    entityQueryingConfig: [_models_1.PriceSet, _models_1.PriceList, _models_1.Price],
+    models: [_models_1.PriceSet, _models_1.PriceList, _models_1.Price],
     linkableKeys: {
         price_set_id: _models_1.PriceSet.name,
         price_list_id: _models_1.PriceList.name,
         price_id: _models_1.Price.name,
     },
 });
-exports.entityNameToLinkableKeysMap = (0, utils_1.buildEntitiesNameToLinkableKeysMap)(exports.joinerConfig.linkableKeys);

package/dist/repositories/pricing.js

@@ -117,6 +117,7 @@ class PricingRepository extends utils_1.MikroOrmBase {
             pl_rules_count: "price.pl_rules_count",
             price_list_type: "price.pl_type",
             price_list_id: "price.price_list_id",
+            all_rules_count: knex.raw("COALESCE(price.rules_count, 0) + COALESCE(price.pl_rules_count, 0)"),
         })
             .join(priceSubQueryKnex.as("price"), "price.price_set_id", "ps.id")
             .leftJoin("price_rule as pr", "pr.price_id", "price.id")
@@ -124,8 +125,8 @@ class PricingRepository extends utils_1.MikroOrmBase {
             .andWhere("price.currency_code", "=", currencyCode)
             .orderBy([
             { column: "price.has_price_list", order: "asc" },
+            { column: "all_rules_count", order: "desc" },
             { column: "amount", order: "asc" },
-            { column: "rules_count", order: "desc" },
         ]);
         if (quantity) {
             priceSetQueryKnex.where("price.min_quantity", "<=", quantity);

package/dist/services/pricing-module.d.ts

@@ -1,5 +1,4 @@
-import { AddPricesDTO, Context, CreatePriceRuleDTO, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceDTO, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, UpsertPriceSetDTO } from "@medusajs/types";
-import { ModulesSdkUtils } from "@medusajs/utils";
+import { AddPricesDTO, Context, CreatePriceRuleDTO, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, UpsertPriceSetDTO } from "@medusajs/types";
 import { Price, PriceList, PriceListRule, PriceRule, PriceSet } from "../models";
 import { ServiceTypes } from "../types";
 import { CreatePriceListDTO } from "src/types/services";
@@ -12,7 +11,7 @@ type InjectedDependencies = {
     priceListService: ModulesSdkTypes.IMedusaInternalService<any>;
     priceListRuleService: ModulesSdkTypes.IMedusaInternalService<any>;
 };
-declare const PricingModuleService_base: new (...args: any[]) => ModulesSdkUtils.AbstractModuleService<{
+declare const PricingModuleService_base: import("@medusajs/utils/dist/modules-sdk/types/medusa-service").MedusaServiceReturnType<{
     PriceSet: {
         dto: PricingTypes.PriceSetDTO;
     };
@@ -43,6 +42,7 @@ export default class PricingModuleService extends PricingModuleService_base impl
     constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, priceListService, priceListRuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     private setupCalculatedPriceConfig_;
+    retrievePriceSet(id: string, config?: FindConfig<PriceSetDTO> | undefined, sharedContext?: Context | undefined): Promise<PriceSetDTO>;
     listPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
     listAndCountPriceSets(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
@@ -52,8 +52,9 @@ export default class PricingModuleService extends PricingModuleService_base impl
     upsertPriceSets(data: UpsertPriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
     updatePriceSets(id: string, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
     updatePriceSets(selector: PricingTypes.FilterablePriceSetProps, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO[]>;
-    private normalizeUpdateData;
     protected updatePriceSets_(data: ServiceTypes.UpdatePriceSetInput[], sharedContext?: Context): Promise<PriceSet[]>;
+    private normalizeUpdateData;
+    private normalizePrices;
     addPrices(data: AddPricesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
     addPrices(data: AddPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
     createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
@@ -73,5 +74,17 @@ export default class PricingModuleService extends PricingModuleService_base impl
     protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
     protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<PriceList[]>;
     protected normalizePriceListDate(data: (ServiceTypes.UpdatePriceListDTO | ServiceTypes.CreatePriceListDTO | CreatePriceListDTO)[]): any[];
+    protected normalizePriceSetConfig(config: FindConfig<PricingTypes.PriceSetDTO> | undefined): {
+        select?: string[] | undefined;
+        skip?: number | null | undefined;
+        take?: number | null | undefined;
+        relations?: string[] | undefined;
+        order?: {
+            [K: string]: "ASC" | "DESC";
+        } | undefined;
+        withDeleted?: boolean | undefined;
+        filters?: Record<string, any> | undefined;
+        options: Record<string, any>;
+    };
 }
 export {};

package/dist/services/pricing-module.js

@@ -24,7 +24,7 @@ const generateMethodForModels = {
     PriceRule: _models_1.PriceRule,
     Price: _models_1.Price,
 };
-class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
     constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, priceListService, priceListRuleService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
@@ -53,53 +53,60 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return pricingContext;
     }
     // @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);
+    }
+    // @ts-expect-error
     async listPriceSets(filters = {}, config = {}, sharedContext = {}) {
-        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
-        const priceSets = await super.listPriceSets(filters, config, sharedContext);
+        const normalizedConfig = this.normalizePriceSetConfig(config);
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, normalizedConfig);
+        const priceSets = await super.listPriceSets(filters, normalizedConfig, sharedContext);
         if (!pricingContext || !priceSets.length) {
             return priceSets;
         }
-        const priceSetIds = [];
-        const priceSetMap = new Map();
-        for (const priceSet of priceSets) {
-            priceSetIds.push(priceSet.id);
-            priceSetMap.set(priceSet.id, priceSet);
-        }
-        const calculatedPrices = await this.calculatePrices({ id: priceSetIds }, { context: pricingContext }, sharedContext);
+        const calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+        const calculatedPricesMap = new Map();
         for (const calculatedPrice of calculatedPrices) {
-            const priceSet = priceSetMap.get(calculatedPrice.id);
-            priceSet.calculated_price = calculatedPrice;
+            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
+        }
+        for (const priceSet of priceSets) {
+            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
+            priceSet.calculated_price = calculatedPrice ?? null;
         }
         return priceSets;
     }
     // @ts-expect-error
     async listAndCountPriceSets(filters = {}, config = {}, sharedContext = {}) {
-        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
-        const [priceSets, count] = await super.listAndCountPriceSets(filters, config, sharedContext);
+        const normalizedConfig = this.normalizePriceSetConfig(config);
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, normalizedConfig);
+        const [priceSets, count] = await super.listAndCountPriceSets(filters, normalizedConfig, sharedContext);
         if (!pricingContext || !priceSets.length) {
             return [priceSets, count];
         }
-        const priceSetIds = [];
-        const priceSetMap = new Map();
-        for (const priceSet of priceSets) {
-            priceSetIds.push(priceSet.id);
-            priceSetMap.set(priceSet.id, priceSet);
-        }
-        const calculatedPrices = await this.calculatePrices({ id: priceSetIds }, { context: pricingContext }, sharedContext);
+        const calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+        const calculatedPricesMap = new Map();
         for (const calculatedPrice of calculatedPrices) {
-            const priceSet = priceSetMap.get(calculatedPrice.id);
-            priceSet.calculated_price = calculatedPrice;
+            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
+        }
+        for (const priceSet of priceSets) {
+            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
+            priceSet.calculated_price = calculatedPrice ?? null;
         }
         return [priceSets, count];
     }
     async calculatePrices(pricingFilters, pricingContext = { context: {} }, sharedContext = {}) {
         const results = await this.pricingRepository_.calculatePrices(pricingFilters, pricingContext, sharedContext);
         const pricesSetPricesMap = (0, utils_1.groupBy)(results, "price_set_id");
-        const calculatedPrices = pricingFilters.id.map((priceSetId) => {
+        const calculatedPrices = pricingFilters.id
+            .map((priceSetId) => {
             // This is where we select prices, for now we just do a first match based on the database results
             // which is prioritized by rules_count first for exact match and then deafult_priority of the rule_type
             // TODO: inject custom price selection here
             const prices = pricesSetPricesMap.get(priceSetId) || [];
+            if (!prices.length) {
+                return null;
+            }
             const priceListPrice = prices.find((p) => p.price_list_id);
             const defaultPrice = prices?.find((p) => !p.price_list_id);
             let calculatedPrice = defaultPrice;
@@ -132,16 +139,17 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                     max_quantity: parseInt(originalPrice?.max_quantity || "") || null,
                 },
             };
-        });
+        })
+            .filter(Boolean);
         return JSON.parse(JSON.stringify(calculatedPrices));
     }
     async createPriceSets(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const priceSets = await this.createPriceSets_(input, sharedContext);
         // TODO: Remove the need to refetch the data here
-        const dbPriceSets = await this.listPriceSets({ id: priceSets.map((p) => p.id) }, {
+        const dbPriceSets = await this.listPriceSets({ id: priceSets.map((p) => p.id) }, this.normalizePriceSetConfig({
             relations: ["prices", "prices.price_rules"],
-        }, sharedContext);
+        }), sharedContext);
         // Ensure the output to be in the same order as the input
         const results = priceSets.map((priceSet) => {
             return dbPriceSets.find((p) => p.id === priceSet.id);
@@ -180,30 +188,6 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const priceSets = await this.baseRepository_.serialize(updateResult);
         return (0, utils_1.isString)(idOrSelector) ? priceSets[0] : priceSets;
     }
-    async normalizeUpdateData(data) {
-        return data.map((priceSet) => {
-            const prices = priceSet.prices?.map((price) => {
-                const rules = Object.entries(price.rules ?? {}).map(([attribute, value]) => {
-                    return {
-                        attribute,
-                        value,
-                    };
-                });
-                const hasRulesInput = (0, utils_1.isPresent)(price.rules);
-                delete price.rules;
-                return {
-                    ...price,
-                    price_set_id: priceSet.id,
-                    price_rules: hasRulesInput ? rules : undefined,
-                    rules_count: hasRulesInput ? rules.length : undefined,
-                };
-            });
-            return {
-                ...priceSet,
-                prices,
-            };
-        });
-    }
     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
@@ -226,6 +210,49 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const { entities: priceSets } = await this.priceSetService_.upsertWithReplace(priceSetsToUpsert, { relations: ["prices"] }, sharedContext);
         return priceSets;
     }
+    async normalizeUpdateData(data) {
+        return data.map((priceSet) => {
+            return {
+                ...priceSet,
+                prices: this.normalizePrices(priceSet.prices?.map((p) => ({ ...p, price_set_id: priceSet.id })), []),
+            };
+        });
+    }
+    normalizePrices(data, existingPrices, priceListId) {
+        const pricesToUpsert = new Map();
+        const existingPricesMap = new Map();
+        existingPrices?.forEach((price) => {
+            existingPricesMap.set(hashPrice(price), price);
+        });
+        data?.forEach((price) => {
+            const cleanRules = price.rules ? (0, utils_1.removeNullish)(price.rules) : {};
+            const ruleEntries = Object.entries(cleanRules);
+            const rules = ruleEntries.map(([attribute, value]) => {
+                return {
+                    attribute,
+                    value,
+                };
+            });
+            const hasRulesInput = (0, utils_1.isPresent)(price.rules);
+            const entry = {
+                ...price,
+                price_list_id: priceListId,
+                price_rules: hasRulesInput ? rules : undefined,
+                rules_count: hasRulesInput ? ruleEntries.length : undefined,
+            };
+            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;
+        });
+        return Array.from(pricesToUpsert.values());
+    }
     async addPrices(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         await this.addPrices_(input, sharedContext);
@@ -269,30 +296,8 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const toCreate = input.map((inputData) => {
             const entry = {
                 ...inputData,
+                prices: this.normalizePrices(inputData.prices, []),
             };
-            if (!inputData.prices) {
-                return entry;
-            }
-            const pricesData = inputData.prices.map((price) => {
-                let { rules: priceRules = {}, ...rest } = price;
-                const cleanRules = priceRules ? (0, utils_1.removeNullish)(priceRules) : {};
-                const rules = Object.entries(cleanRules);
-                const numberOfRules = rules.length;
-                const rulesDataMap = new Map();
-                rules.map(([attribute, value]) => {
-                    const rule = {
-                        attribute,
-                        value,
-                    };
-                    rulesDataMap.set(JSON.stringify(rule), rule);
-                });
-                return {
-                    ...rest,
-                    rules_count: numberOfRules,
-                    price_rules: Array.from(rulesDataMap.values()),
-                };
-            });
-            entry.prices = pricesData;
             return entry;
         });
         // Bulk create price sets
@@ -332,58 +337,50 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return createdPriceSets;
     }
     async addPrices_(input, sharedContext = {}) {
-        const priceSets = await this.listPriceSets({ id: input.map((d) => d.priceSetId) }, {}, sharedContext);
+        const priceSets = await this.listPriceSets({ id: input.map((d) => d.priceSetId) }, { take: null, relations: ["prices", "prices.price_rules"] }, sharedContext);
+        const existingPrices = priceSets
+            .map((p) => p.prices)
+            .flat();
+        const pricesToUpsert = input
+            .map((addPrice) => this.normalizePrices(addPrice.prices?.map((p) => ({
+            ...p,
+            price_set_id: addPrice.priceSetId,
+        })), existingPrices))
+            .filter(Boolean)
+            .flat();
         const priceSetMap = new Map(priceSets.map((p) => [p.id, p]));
-        input.forEach(({ priceSetId }) => {
-            const priceSet = priceSetMap.get(priceSetId);
+        pricesToUpsert.forEach((price) => {
+            const priceSet = priceSetMap.get(price.price_set_id);
             if (!priceSet) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price set with id: ${priceSetId} not found`);
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price set with id: ${price.price_set_id} not found`);
             }
         });
-        const pricesToCreate = input.flatMap(({ priceSetId, prices }) => prices.map((price) => {
-            const numberOfRules = Object.entries(price?.rules ?? {}).length;
-            const priceRules = Object.entries(price.rules ?? {}).map(([attribute, value]) => ({
-                price_set_id: priceSetId,
-                attribute: attribute,
-                value,
-            }));
-            return {
-                ...price,
-                price_set_id: priceSetId,
-                rules_count: numberOfRules,
-                price_rules: priceRules,
-            };
-        }));
-        const prices = await this.priceService_.create(pricesToCreate, sharedContext);
-        /**
-         * Preparing data for emitting events
-         */
-        const eventsData = prices.reduce((eventsData, price) => {
-            eventsData.prices.push({
-                id: price.id,
-            });
-            price.price_rules.map((priceRule) => {
-                eventsData.priceRules.push({
-                    id: priceRule.id,
-                });
-            });
-            return eventsData;
-        }, {
-            priceRules: [],
-            prices: [],
-        });
-        /**
-         * Emitting events for all created entities
-         */
+        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
         _utils_1.eventBuilders.createdPrice({
-            data: eventsData.prices,
+            data: performedActions.created[_models_1.Price.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.updatedPrice({
+            data: performedActions.updated[_models_1.Price.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.deletedPrice({
+            data: performedActions.deleted[_models_1.Price.name] ?? [],
             sharedContext,
         });
         _utils_1.eventBuilders.createdPriceRule({
-            data: eventsData.priceRules,
+            data: performedActions.created[_models_1.PriceRule.name] ?? [],
             sharedContext,
         });
-        return prices;
+        _utils_1.eventBuilders.updatedPriceRule({
+            data: performedActions.updated[_models_1.PriceRule.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.deletedPriceRule({
+            data: performedActions.deleted[_models_1.PriceRule.name] ?? [],
+            sharedContext,
+        });
+        return entities;
     }
     async createPriceLists_(data, sharedContext = {}) {
         const normalized = this.normalizePriceListDate(data);
@@ -393,26 +390,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 rules: undefined,
             };
             if (priceListData.prices) {
-                const pricesData = priceListData.prices.map((price) => {
-                    let { rules: priceRules = {}, ...rest } = price;
-                    const cleanRules = priceRules ? (0, utils_1.removeNullish)(priceRules) : {};
-                    const rules = Object.entries(cleanRules);
-                    const numberOfRules = rules.length;
-                    const rulesDataMap = new Map();
-                    rules.map(([attribute, value]) => {
-                        const rule = {
-                            attribute,
-                            value,
-                        };
-                        rulesDataMap.set(JSON.stringify(rule), rule);
-                    });
-                    return {
-                        ...rest,
-                        rules_count: numberOfRules,
-                        price_rules: Array.from(rulesDataMap.values()),
-                    };
-                });
-                entry.prices = pricesData;
+                entry.prices = this.normalizePrices(priceListData.prices, []);
             }
             if (priceListData.rules) {
                 const cleanRules = priceListData.rules
@@ -521,111 +499,69 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return entities;
     }
     async updatePriceListPrices_(data, sharedContext = {}) {
-        const priceListIds = [];
-        const priceIds = [];
-        for (const priceListData of data) {
-            priceListIds.push(priceListData.price_list_id);
-            for (const price of priceListData.prices) {
-                priceIds.push(price.id);
-            }
-        }
-        const prices = await this.listPrices({ id: priceIds }, { take: null, relations: ["price_rules"] }, sharedContext);
-        const priceMap = new Map(prices.map((price) => [price.id, price]));
-        const priceLists = await this.listPriceLists({ id: priceListIds }, { take: null }, sharedContext);
+        const priceLists = await this.listPriceLists({ id: data.map((p) => p.price_list_id) }, { take: null, relations: ["prices", "prices.price_rules"] }, sharedContext);
+        const existingPrices = priceLists
+            .map((p) => p.prices ?? [])
+            .flat();
+        const pricesToUpsert = data
+            .map((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
+            .filter(Boolean)
+            .flat();
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
-        const pricesToUpdate = [];
-        const priceRuleIdsToDelete = [];
-        const priceRulesToCreate = [];
         for (const { price_list_id: priceListId, prices } of data) {
             const priceList = priceListMap.get(priceListId);
             if (!priceList) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
-            for (const priceData of prices) {
-                const { rules = {}, price_set_id, ...rest } = priceData;
-                const price = priceMap.get(rest.id);
-                const priceRules = price.price_rules;
-                priceRulesToCreate.push(...Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({
-                    price_set_id,
-                    attribute: ruleAttribute,
-                    value: ruleValue,
-                    price_id: price.id,
-                })));
-                pricesToUpdate.push({
-                    ...rest,
-                    rules_count: Object.keys(rules).length,
-                });
-                priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id));
-            }
         }
-        const [_deletedPriceRule, _createdPriceRule, updatedPrices] = await (0, utils_1.promiseAll)([
-            this.priceRuleService_.delete(priceRuleIdsToDelete),
-            this.priceRuleService_.create(priceRulesToCreate),
-            this.priceService_.update(pricesToUpdate),
-        ]);
-        return updatedPrices;
+        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 priceListIds = [];
-        for (const priceListData of data) {
-            priceListIds.push(priceListData.price_list_id);
-        }
-        const priceLists = await this.listPriceLists({ id: priceListIds }, {}, sharedContext);
+        const priceLists = await this.listPriceLists({ id: data.map((p) => p.price_list_id) }, { take: null, relations: ["prices", "prices.price_rules"] }, sharedContext);
+        const existingPrices = priceLists
+            .map((p) => p.prices ?? [])
+            .flat();
+        const pricesToUpsert = data
+            .map((addPrice) => this.normalizePrices(addPrice.prices, existingPrices, addPrice.price_list_id))
+            .filter(Boolean)
+            .flat();
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
-        const pricesToCreate = [];
-        for (const { price_list_id: priceListId, prices } of data) {
-            const priceList = priceListMap.get(priceListId);
+        pricesToUpsert.forEach((price) => {
+            const priceList = priceListMap.get(price.price_list_id);
             if (!priceList) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${price.price_list_id} not found`);
             }
-            const priceListPricesToCreate = prices.map((priceData) => {
-                const priceRules = priceData.rules || {};
-                const noOfRules = Object.keys(priceRules).length;
-                const priceRulesToCreate = Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
-                    return {
-                        price_list_id: priceData.price_set_id,
-                        attribute: ruleAttribute,
-                        value: ruleValue,
-                    };
-                });
-                return {
-                    ...priceData,
-                    price_set_id: priceData.price_set_id,
-                    title: "test",
-                    price_list_id: priceList.id,
-                    rules_count: noOfRules,
-                    price_rules: priceRulesToCreate,
-                };
-            });
-            pricesToCreate.push(...priceListPricesToCreate);
-        }
-        const createdPrices = await this.priceService_.create(pricesToCreate, sharedContext);
-        const eventsData = createdPrices.reduce((eventsData, price) => {
-            eventsData.prices.push({
-                id: price.id,
-            });
-            price.price_rules.map((priceRule) => {
-                eventsData.priceRules.push({
-                    id: priceRule.id,
-                });
-            });
-            return eventsData;
-        }, {
-            priceRules: [],
-            prices: [],
         });
+        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
         _utils_1.eventBuilders.createdPrice({
-            data: eventsData.prices,
+            data: performedActions.created[_models_1.Price.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.updatedPrice({
+            data: performedActions.updated[_models_1.Price.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.deletedPrice({
+            data: performedActions.deleted[_models_1.Price.name] ?? [],
             sharedContext,
         });
         _utils_1.eventBuilders.createdPriceRule({
-            data: eventsData.priceRules,
+            data: performedActions.created[_models_1.PriceRule.name] ?? [],
             sharedContext,
         });
-        return createdPrices;
+        _utils_1.eventBuilders.updatedPriceRule({
+            data: performedActions.updated[_models_1.PriceRule.name] ?? [],
+            sharedContext,
+        });
+        _utils_1.eventBuilders.deletedPriceRule({
+            data: performedActions.deleted[_models_1.PriceRule.name] ?? [],
+            sharedContext,
+        });
+        return entities;
     }
     async setPriceListRules_(data, sharedContext = {}) {
         // TODO: re think this method
@@ -719,8 +655,24 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
             return priceListData;
         });
     }
+    normalizePriceSetConfig(config) {
+        return {
+            options: {
+                populateWhere: { prices: { price_list_id: null } },
+            },
+            ...config,
+        };
+    }
 }
 exports.default = PricingModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_")
+    // @ts-expect-error
+    ,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "retrievePriceSet", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-expect-error
@@ -896,3 +848,19 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "removePriceListRules_", null);
+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));
+};

package/dist/types/services/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./price-list";
 export * from "./price-set";
+export * from "./price";

package/dist/types/services/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./price-list"), exports);
 __exportStar(require("./price-set"), exports);
+__exportStar(require("./price"), exports);

package/dist/types/services/price.d.ts

@@ -0,0 +1,6 @@
+import { PricingTypes } from "@medusajs/types";
+export interface UpsertPriceDTO extends Omit<PricingTypes.CreatePriceDTO, "rules"> {
+    id?: string;
+    price_list_id?: string;
+    price_rules: PricingTypes.CreatePriceRuleDTO[];
+}

package/dist/types/services/price.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/events.d.ts

@@ -35,4 +35,28 @@ export declare const eventBuilders: {
         }[];
         sharedContext: import("@medusajs/types").Context;
     }) => void;
+    updatedPrice: ({ data, sharedContext, }: {
+        data: {
+            id: string;
+        }[];
+        sharedContext: import("@medusajs/types").Context;
+    }) => void;
+    updatedPriceRule: ({ data, sharedContext, }: {
+        data: {
+            id: string;
+        }[];
+        sharedContext: import("@medusajs/types").Context;
+    }) => void;
+    deletedPrice: ({ data, sharedContext, }: {
+        data: {
+            id: string;
+        }[];
+        sharedContext: import("@medusajs/types").Context;
+    }) => void;
+    deletedPriceRule: ({ data, sharedContext, }: {
+        data: {
+            id: string;
+        }[];
+        sharedContext: import("@medusajs/types").Context;
+    }) => void;
 };

package/dist/utils/events.js

@@ -39,4 +39,28 @@ exports.eventBuilders = {
         object: "price_list_rule",
         eventsEnum: utils_1.PricingEvents,
     }),
+    updatedPrice: (0, utils_1.eventBuilderFactory)({
+        source: utils_1.Modules.PRICING,
+        action: utils_1.CommonEvents.UPDATED,
+        object: "price",
+        eventsEnum: utils_1.PricingEvents,
+    }),
+    updatedPriceRule: (0, utils_1.eventBuilderFactory)({
+        source: utils_1.Modules.PRICING,
+        action: utils_1.CommonEvents.UPDATED,
+        object: "price_rule",
+        eventsEnum: utils_1.PricingEvents,
+    }),
+    deletedPrice: (0, utils_1.eventBuilderFactory)({
+        source: utils_1.Modules.PRICING,
+        action: utils_1.CommonEvents.DELETED,
+        object: "price",
+        eventsEnum: utils_1.PricingEvents,
+    }),
+    deletedPriceRule: (0, utils_1.eventBuilderFactory)({
+        source: utils_1.Modules.PRICING,
+        action: utils_1.CommonEvents.DELETED,
+        object: "price_rule",
+        eventsEnum: utils_1.PricingEvents,
+    }),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/pricing",
-  "version": "0.1.13-snapshot-20240701122250",
+  "version": "0.1.13-snapshot-20240704061641",
   "description": "Medusa Pricing module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,7 +37,7 @@
     "@mikro-orm/cli": "5.9.7",
     "cross-env": "^5.2.1",
     "jest": "^29.7.0",
-    "medusa-test-utils": "1.1.45-snapshot-20240701122250",
+    "medusa-test-utils": "1.1.45-snapshot-20240704061641",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
@@ -45,9 +45,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "1.13.0-snapshot-20240701122250",
-    "@medusajs/types": "1.12.0-snapshot-20240701122250",
-    "@medusajs/utils": "1.12.0-snapshot-20240701122250",
+    "@medusajs/modules-sdk": "1.13.0-snapshot-20240704061641",
+    "@medusajs/types": "1.12.0-snapshot-20240704061641",
+    "@medusajs/utils": "1.12.0-snapshot-20240704061641",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",