@medusajs/pricing 0.1.13-snapshot-20240718073308 → 0.1.13

package/dist/services/pricing-module.js

@@ -17,27 +17,33 @@ const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
-const generateMethodForModels = {
-    PriceSet: _models_1.PriceSet,
-    PriceList: _models_1.PriceList,
-    PriceListRule: _models_1.PriceListRule,
-    PriceRule: _models_1.PriceRule,
-    Price: _models_1.Price,
-    PricePreference: _models_1.PricePreference,
-};
-class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
-    constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, pricePreferenceService, priceListService, priceListRuleService, }, moduleDeclaration) {
+const price_list_1 = require("../models/price-list");
+const price_set_1 = require("../models/price-set");
+const generateMethodForModels = [
+    _models_1.PriceList,
+    _models_1.PriceListRule,
+    _models_1.PriceListRuleValue,
+    _models_1.PriceRule,
+    _models_1.Price,
+    _models_1.PriceSetRuleType,
+    _models_1.RuleType,
+];
+class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.PriceSet, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+    constructor({ baseRepository, pricingRepository, ruleTypeService, priceSetService, priceRuleService, priceSetRuleTypeService, priceService, priceListService, priceListRuleService, priceListRuleValueService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
         this.pricingRepository_ = pricingRepository;
+        this.ruleTypeService_ = ruleTypeService;
         this.priceSetService_ = priceSetService;
+        this.ruleTypeService_ = ruleTypeService;
         this.priceRuleService_ = priceRuleService;
+        this.priceSetRuleTypeService_ = priceSetRuleTypeService;
         this.priceService_ = priceService;
-        this.pricePreferenceService_ = pricePreferenceService;
         this.priceListService_ = priceListService;
         this.priceListRuleService_ = priceListRuleService;
+        this.priceListRuleValueService_ = priceListRuleValueService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
@@ -45,69 +51,61 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     setupCalculatedPriceConfig_(filters, config) {
         const fieldIdx = config.relations?.indexOf("calculated_price");
         const shouldCalculatePrice = fieldIdx > -1;
-        const pricingContext = filters.context ?? {};
-        delete filters.context;
         if (!shouldCalculatePrice) {
             return;
         }
+        let pricingContext = filters.context ?? {};
         // cleanup virtual field "calculated_price"
         config.relations?.splice(fieldIdx, 1);
+        delete filters.context;
         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 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 calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
-        const calculatedPricesMap = new Map();
-        for (const calculatedPrice of calculatedPrices) {
-            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
-        }
-        for (const priceSet of priceSets) {
-            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
-            priceSet.calculated_price = calculatedPrice ?? null;
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
+        const priceSets = await super.list(filters, config, sharedContext);
+        if (pricingContext && priceSets.length) {
+            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: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+            for (const calculatedPrice of calculatedPrices) {
+                const priceSet = priceSetMap.get(calculatedPrice.id);
+                priceSet.calculated_price = calculatedPrice;
+            }
         }
         return priceSets;
     }
-    // @ts-expect-error
-    async 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 calculatedPrices = await this.calculatePrices({ id: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
-        const calculatedPricesMap = new Map();
-        for (const calculatedPrice of calculatedPrices) {
-            calculatedPricesMap.set(calculatedPrice.id, calculatedPrice);
-        }
-        for (const priceSet of priceSets) {
-            const calculatedPrice = calculatedPricesMap.get(priceSet.id);
-            priceSet.calculated_price = calculatedPrice ?? null;
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
+        const [priceSets, count] = await super.listAndCount(filters, config, sharedContext);
+        if (pricingContext && priceSets.length) {
+            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: priceSets.map((p) => p.id) }, { context: pricingContext }, sharedContext);
+            for (const calculatedPrice of calculatedPrices) {
+                const priceSet = priceSetMap.get(calculatedPrice.id);
+                priceSet.calculated_price = calculatedPrice;
+            }
         }
         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 priceIds = [];
-        pricesSetPricesMap.forEach((prices, key) => {
+        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) || [];
             const priceListPrice = prices.find((p) => p.price_list_id);
             const defaultPrice = prices?.find((p) => !p.price_list_id);
-            if (!prices.length || (!priceListPrice && !defaultPrice)) {
-                pricesSetPricesMap.delete(key);
-                return;
-            }
             let calculatedPrice = defaultPrice;
             let originalPrice = defaultPrice;
             if (priceListPrice) {
@@ -116,43 +114,12 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                     originalPrice = priceListPrice;
                 }
             }
-            pricesSetPricesMap.set(key, { calculatedPrice, originalPrice });
-            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 }, { take: null });
-        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 prices = pricesSetPricesMap.get(priceSetId);
-            if (!prices) {
-                return null;
-            }
-            const { calculatedPrice, originalPrice, } = prices;
             return {
                 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),
-                calculated_amount: parseFloat(calculatedPrice?.amount || "") || null,
-                raw_calculated_amount: calculatedPrice?.raw_amount || null,
+                calculated_amount: parseInt(calculatedPrice?.amount || "") || null,
                 is_original_price_price_list: !!originalPrice?.price_list_id,
-                is_original_price_tax_inclusive: originalPrice?.id
-                    ? isTaxInclusive(priceRulesPriceMap.get(originalPrice.id), pricingPreferences, originalPrice.currency_code || calculatedPrice.currency_code, pricingContext.context?.region_id)
-                    : false,
-                original_amount: parseFloat(originalPrice?.amount || "") || null,
-                raw_original_amount: originalPrice?.raw_amount || null,
+                original_amount: parseInt(originalPrice?.amount || "") || null,
                 currency_code: calculatedPrice?.currency_code || null,
                 calculated_price: {
                     id: calculatedPrice?.id || null,
@@ -169,38 +136,35 @@ 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 = {}) {
+    async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const priceSets = await this.createPriceSets_(input, sharedContext);
+        const priceSets = await this.create_(input, sharedContext);
         // TODO: Remove the need to refetch the data here
-        const dbPriceSets = await this.listPriceSets({ id: priceSets.map((p) => p.id) }, this.normalizePriceSetConfig({
-            relations: ["prices", "prices.price_rules"],
-        }), sharedContext);
+        const dbPriceSets = await this.list({ id: priceSets.map((p) => p.id) }, { relations: ["rule_types", "prices", "price_rules"] }, 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);
         });
         return await this.baseRepository_.serialize(Array.isArray(data) ? results : results[0]);
     }
-    async upsertPriceSets(data, sharedContext = {}) {
+    async upsert(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const forUpdate = input.filter((priceSet) => !!priceSet.id);
         const forCreate = input.filter((priceSet) => !priceSet.id);
         const operations = [];
         if (forCreate.length) {
-            operations.push(this.createPriceSets_(forCreate, sharedContext));
+            operations.push(this.create_(forCreate, sharedContext));
         }
         if (forUpdate.length) {
-            operations.push(this.updatePriceSets_(forUpdate, sharedContext));
+            operations.push(this.update_(forUpdate, sharedContext));
         }
         const result = (await (0, utils_1.promiseAll)(operations)).flat();
         return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
     }
-    async updatePriceSets(idOrSelector, data, sharedContext = {}) {
+    async update(idOrSelector, data, sharedContext = {}) {
         let normalizedInput = [];
         if ((0, utils_1.isString)(idOrSelector)) {
             // Check if the ID exists, it will throw if not.
@@ -214,16 +178,53 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 ...data,
             }));
         }
-        const updateResult = await this.updatePriceSets_(normalizedInput, sharedContext);
+        const updateResult = await this.update_(normalizedInput, sharedContext);
         const priceSets = await this.baseRepository_.serialize(updateResult);
         return (0, utils_1.isString)(idOrSelector) ? priceSets[0] : priceSets;
     }
-    async updatePriceSets_(data, sharedContext = {}) {
+    async normalizeUpdateData(data, sharedContext) {
+        const ruleAttributes = data
+            .map((d) => d.prices?.map((p) => Object.keys(p.rules ?? [])) ?? [])
+            .flat(Infinity)
+            .filter(Boolean);
+        const ruleTypes = await this.ruleTypeService_.list({ rule_attribute: ruleAttributes }, { take: null }, sharedContext);
+        const ruleTypeMap = ruleTypes.reduce((acc, curr) => {
+            acc.set(curr.rule_attribute, curr);
+            return acc;
+        }, new Map());
+        return data.map((priceSet) => {
+            const prices = priceSet.prices?.map((price) => {
+                const rules = Object.entries(price.rules ?? {}).map(([attribute, value]) => {
+                    return {
+                        price_set_id: priceSet.id,
+                        rule_type_id: ruleTypeMap.get(attribute).id,
+                        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 update_(data, sharedContext = {}) {
+        // TODO: We are not handling rule types, rules, etc. here, add support after data models are finalized
         // 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 normalizedData = await this.normalizeUpdateData(data, sharedContext);
         const prices = normalizedData.flatMap((priceSet) => priceSet.prices || []);
-        const { entities: upsertedPrices } = await this.priceService_.upsertWithReplace(prices, { relations: ["price_rules"] }, sharedContext);
+        const upsertedPrices = await this.priceService_.upsertWithReplace(prices, {
+            relations: ["price_rules"],
+        }, sharedContext);
         const priceSetsToUpsert = normalizedData.map((priceSet) => {
             const { prices, ...rest } = priceSet;
             return {
@@ -237,71 +238,61 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 }),
             };
         });
-        const { entities: priceSets } = await this.priceSetService_.upsertWithReplace(priceSetsToUpsert, { relations: ["prices"] }, sharedContext);
-        return priceSets;
+        return await this.priceSetService_.upsertWithReplace(priceSetsToUpsert, { relations: ["prices"] }, sharedContext);
     }
-    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;
+    async addRules(data, sharedContext = {}) {
+        const inputs = Array.isArray(data) ? data : [data];
+        const priceSets = await this.addRules_(inputs, sharedContext);
+        const dbPriceSets = await this.list({ id: priceSets.map(({ id }) => id) }, { relations: ["rule_types"] });
+        const orderedPriceSets = priceSets.map((priceSet) => {
+            return dbPriceSets.find((p) => p.id === priceSet.id);
         });
-        return Array.from(pricesToUpsert.values());
+        return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0];
     }
     async addPrices(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         await this.addPrices_(input, sharedContext);
-        const dbPrices = await this.listPriceSets({ id: input.map((d) => d.priceSetId) }, { relations: ["prices"] }, sharedContext);
+        const dbPrices = await this.list({ id: input.map((d) => d.priceSetId) }, { relations: ["prices"] }, sharedContext);
         const orderedPriceSets = input.map((inputItem) => {
             return dbPrices.find((p) => p.id === inputItem.priceSetId);
         });
         return Array.isArray(data) ? orderedPriceSets : orderedPriceSets[0];
     }
-    // @ts-ignore
+    async removeRules(data, sharedContext = {}) {
+        const priceSets = await this.priceSetService_.list({ id: data.map((d) => d.id) }, {}, sharedContext);
+        const priceSetIds = priceSets.map((ps) => ps.id);
+        const ruleTypes = await this.ruleTypeService_.list({
+            rule_attribute: data.map((d) => d.rules || []).flat(),
+        }, { take: null }, sharedContext);
+        const ruleTypeIds = ruleTypes.map((rt) => rt.id);
+        const priceSetRuleTypes = await this.priceSetRuleTypeService_.list({ price_set_id: priceSetIds, rule_type_id: ruleTypeIds }, { take: null }, sharedContext);
+        const priceRules = await this.priceRuleService_.list({ price_set_id: priceSetIds, rule_type_id: ruleTypeIds }, { select: ["price"], take: null }, sharedContext);
+        await this.priceSetRuleTypeService_.delete(priceSetRuleTypes.map((psrt) => psrt.id), sharedContext);
+        await this.priceService_.delete(priceRules.map((pr) => pr.price.id), sharedContext);
+    }
     async createPriceLists(data, sharedContext = {}) {
         const priceLists = await this.createPriceLists_(data, sharedContext);
         return await this.baseRepository_.serialize(priceLists);
     }
-    // @ts-ignore
     async updatePriceLists(data, sharedContext = {}) {
         const priceLists = await this.updatePriceLists_(data, sharedContext);
         return await this.baseRepository_.serialize(priceLists);
     }
+    async createPriceListRules(data, sharedContext = {}) {
+        const priceLists = await this.createPriceListRules_(data, sharedContext);
+        return await this.baseRepository_.serialize(priceLists, {
+            populate: true,
+        });
+    }
+    async createPriceListRules_(data, sharedContext = {}) {
+        return await this.priceListRuleService_.create(data, sharedContext);
+    }
+    async updatePriceListRules(data, sharedContext = {}) {
+        const priceLists = await this.priceListRuleService_.update(data, sharedContext);
+        return await this.baseRepository_.serialize(priceLists, {
+            populate: true,
+        });
+    }
     async updatePriceListPrices(data, sharedContext = {}) {
         const prices = await this.updatePriceListPrices_(data, sharedContext);
         return await this.baseRepository_.serialize(prices);
@@ -321,455 +312,505 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         const [priceList] = await this.removePriceListRules_([data], sharedContext);
         return await this.baseRepository_.serialize(priceList);
     }
-    async createPricePreferences(data, sharedContext = {}) {
-        const normalized = Array.isArray(data) ? data : [data];
-        const preferences = await this.createPricePreferences_(normalized, sharedContext);
-        const serialized = await this.baseRepository_.serialize(preferences);
-        return Array.isArray(data) ? serialized : serialized[0];
-    }
-    async upsertPricePreferences(data, sharedContext = {}) {
+    async create_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const forUpdate = input.filter((pricePreference) => !!pricePreference.id);
-        const forCreate = input.filter((pricePreference) => !pricePreference.id);
-        const operations = [];
-        if (forCreate.length) {
-            operations.push(this.createPricePreferences_(forCreate, sharedContext));
+        const ruleAttributes = data
+            .map((d) => d.rules?.map((r) => r.rule_attribute) ?? [])
+            .flat();
+        const ruleTypes = await this.ruleTypeService_.list({ rule_attribute: ruleAttributes }, { take: null }, sharedContext);
+        const ruleTypeMap = ruleTypes.reduce((acc, curr) => {
+            acc.set(curr.rule_attribute, curr);
+            return acc;
+        }, new Map());
+        const invalidRuleAttributes = ruleAttributes.filter((r) => !ruleTypeMap.has(r));
+        if (invalidRuleAttributes.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Rule types don't exist for: ${invalidRuleAttributes.join(", ")}`);
         }
-        if (forUpdate.length) {
-            operations.push(this.updatePricePreferences_(forUpdate, sharedContext));
+        const invalidMoneyAmountRule = data
+            .map((d) => d.prices?.map((ma) => Object.keys(ma?.rules ?? {})).flat() ?? [])
+            .flat()
+            .filter((r) => !ruleTypeMap.has(r));
+        if (invalidMoneyAmountRule.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Rule types don't exist for money amounts with rule attribute: ${invalidMoneyAmountRule.join(", ")}`);
         }
-        const result = (await (0, utils_1.promiseAll)(operations)).flat();
-        return await this.baseRepository_.serialize(Array.isArray(data) ? result : result[0]);
-    }
-    async updatePricePreferences(idOrSelector, data, sharedContext = {}) {
-        let normalizedInput = [];
-        if ((0, utils_1.isString)(idOrSelector)) {
-            // Check if the ID exists, it will throw if not.
-            await this.pricePreferenceService_.retrieve(idOrSelector, {}, sharedContext);
-            normalizedInput = [{ id: idOrSelector, ...data }];
-        }
-        else {
-            const pricePreferences = await this.pricePreferenceService_.list(idOrSelector, {}, sharedContext);
-            normalizedInput = pricePreferences.map((pricePreference) => ({
-                id: pricePreference.id,
-                ...data,
-            }));
-        }
-        const updateResult = await this.updatePricePreferences_(normalizedInput, sharedContext);
-        const pricePreferences = await this.baseRepository_.serialize(updateResult);
-        return (0, utils_1.isString)(idOrSelector) ? pricePreferences[0] : pricePreferences;
-    }
-    async createPricePreferences_(data, sharedContext = {}) {
-        const preferences = await this.pricePreferenceService_.create(data.map((d) => ({
-            ...d,
-            is_tax_inclusive: d.is_tax_inclusive ?? false,
-        })), sharedContext);
-        return preferences;
-    }
-    async updatePricePreferences_(data, sharedContext = {}) {
-        const preferences = await this.pricePreferenceService_.update(data, sharedContext);
-        return preferences;
-    }
-    async createPriceSets_(data, sharedContext = {}) {
-        const input = Array.isArray(data) ? data : [data];
+        const ruleSetRuleTypeToCreateMap = new Map();
         const toCreate = input.map((inputData) => {
-            const entry = {
-                ...inputData,
-                prices: this.normalizePrices(inputData.prices, []),
+            const id = (0, utils_1.generateEntityId)(inputData.id, price_set_1.PriceSetIdPrefix);
+            const { prices, rules = [], ...rest } = inputData;
+            let pricesData = [];
+            rules.forEach((rule) => {
+                const priceSetRuleType = {
+                    rule_type_id: ruleTypeMap.get(rule.rule_attribute).id,
+                    price_set_id: id,
+                };
+                ruleSetRuleTypeToCreateMap.set(JSON.stringify(priceSetRuleType), priceSetRuleType);
+            });
+            if (inputData.prices) {
+                pricesData = inputData.prices.map((price) => {
+                    let { rules: priceRules = {}, ...rest } = price;
+                    const cleanRules = priceRules ? (0, utils_1.removeNullish)(priceRules) : {};
+                    const numberOfRules = Object.keys(cleanRules).length;
+                    const rulesDataMap = new Map();
+                    Object.entries(priceRules).map(([attribute, value]) => {
+                        const rule = {
+                            price_set_id: id,
+                            rule_type_id: ruleTypeMap.get(attribute).id,
+                            value,
+                        };
+                        rulesDataMap.set(JSON.stringify(rule), rule);
+                        const priceSetRuleType = {
+                            rule_type_id: ruleTypeMap.get(attribute).id,
+                            price_set_id: id,
+                        };
+                        ruleSetRuleTypeToCreateMap.set(JSON.stringify(priceSetRuleType), priceSetRuleType);
+                    });
+                    return {
+                        ...rest,
+                        title: "",
+                        rules_count: numberOfRules,
+                        price_rules: Array.from(rulesDataMap.values()),
+                    };
+                });
+            }
+            return {
+                ...rest,
+                id,
+                prices: pricesData,
             };
-            return entry;
         });
         // Bulk create price sets
         const createdPriceSets = await this.priceSetService_.create(toCreate, sharedContext);
-        const eventsData = createdPriceSets.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,
-                    });
+        if (ruleSetRuleTypeToCreateMap.size) {
+            await this.priceSetRuleTypeService_.create(Array.from(ruleSetRuleTypeToCreateMap.values()), sharedContext);
+        }
+        return createdPriceSets;
+    }
+    async addRules_(inputs, sharedContext = {}) {
+        const priceSets = await this.priceSetService_.list({ id: inputs.map((d) => d.priceSetId) }, { relations: ["rule_types"] }, sharedContext);
+        const priceSetRuleTypeMap = new Map(priceSets.map((priceSet) => [
+            priceSet.id,
+            new Map([...priceSet.rule_types].map((rt) => [rt.rule_attribute, rt])),
+        ]));
+        const priceSetMap = new Map(priceSets.map((p) => [p.id, p]));
+        const invalidPriceSetInputs = inputs.filter((d) => !priceSetMap.has(d.priceSetId));
+        if (invalidPriceSetInputs.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `PriceSets with ids: ${invalidPriceSetInputs
+                .map((d) => d.priceSetId)
+                .join(", ")} was not found`);
+        }
+        const ruleTypes = await this.ruleTypeService_.list({
+            rule_attribute: inputs
+                .map((data) => data.rules.map((r) => r.attribute))
+                .flat(),
+        }, { take: null }, sharedContext);
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        const invalidRuleAttributeInputs = inputs
+            .map((d) => d.rules.map((r) => r.attribute))
+            .flat()
+            .filter((r) => !ruleTypeMap.has(r));
+        if (invalidRuleAttributeInputs.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Rule types don't exist for attributes: ${[
+                ...new Set(invalidRuleAttributeInputs),
+            ].join(", ")}`);
+        }
+        const priceSetRuleTypesCreate = [];
+        inputs.forEach((data) => {
+            for (const rule of data.rules) {
+                if (priceSetRuleTypeMap.get(data.priceSetId).has(rule.attribute)) {
+                    continue;
+                }
+                priceSetRuleTypesCreate.push({
+                    rule_type_id: ruleTypeMap.get(rule.attribute).id,
+                    price_set_id: priceSetMap.get(data.priceSetId).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 createdPriceSets;
+        await this.priceSetRuleTypeService_.create(priceSetRuleTypesCreate, sharedContext);
+        return priceSets;
     }
     async addPrices_(input, 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 priceSets = await this.list({ id: input.map((d) => d.priceSetId) }, { relations: ["rule_types"] }, sharedContext);
         const priceSetMap = new Map(priceSets.map((p) => [p.id, p]));
-        pricesToUpsert.forEach((price) => {
-            const priceSet = priceSetMap.get(price.price_set_id);
+        const ruleTypeMap = new Map(priceSets.map((priceSet) => [
+            priceSet.id,
+            new Map(priceSet.rule_types?.map((rt) => [rt.rule_attribute, rt]) ?? []),
+        ]));
+        input.forEach(({ priceSetId, prices }) => {
+            const priceSet = priceSetMap.get(priceSetId);
             if (!priceSet) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price set with id: ${price.price_set_id} not found`);
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price set with id: ${priceSetId} not found`);
+            }
+            const ruleAttributes = prices
+                .map((d) => (d.rules ? Object.keys(d.rules) : []))
+                .flat();
+            const invalidRuleAttributes = ruleAttributes.filter((r) => !ruleTypeMap.get(priceSetId).has(r));
+            if (invalidRuleAttributes.length > 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Rule types don't exist for: ${invalidRuleAttributes.join(", ")}`);
             }
         });
-        const { entities, performedActions } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
-        _utils_1.eventBuilders.createdPrice({
-            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: performedActions.created[_models_1.PriceRule.name] ?? [],
-            sharedContext,
-        });
-        _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;
+        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]) => ({
+                rule_type_id: ruleTypeMap.get(priceSetId).get(attribute).id,
+                price_set_id: priceSetId,
+                value,
+            }));
+            return {
+                ...price,
+                price_set_id: priceSetId,
+                title: "test",
+                rules_count: numberOfRules,
+                priceRules,
+            };
+        }));
+        await this.priceService_.create(pricesToCreate, sharedContext);
     }
     async createPriceLists_(data, sharedContext = {}) {
-        const normalized = this.normalizePriceListDate(data);
-        const priceListsToCreate = normalized.map((priceListData) => {
-            const entry = {
-                ...priceListData,
-                rules: undefined,
-            };
-            if (priceListData.prices) {
-                entry.prices = this.normalizePrices(priceListData.prices, []);
+        const ruleTypeAttributes = [];
+        for (const priceListData of data) {
+            const { prices = [], rules: priceListRules = {} } = priceListData;
+            ruleTypeAttributes.push(...Object.keys(priceListRules));
+            for (const price of prices) {
+                const { rules: priceListPriceRules = {} } = price;
+                ruleTypeAttributes.push(...Object.keys(priceListPriceRules));
             }
-            if (priceListData.rules) {
-                const cleanRules = priceListData.rules
-                    ? (0, utils_1.removeNullish)(priceListData.rules)
-                    : {};
-                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);
-                });
-                entry.price_list_rules = Array.from(rulesDataMap.values());
-                entry.rules_count = numberOfRules;
-            }
-            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,
-                });
+        }
+        const ruleTypes = await this.listRuleTypes({ rule_attribute: ruleTypeAttributes }, { take: null }, sharedContext);
+        const invalidRuleTypes = (0, utils_1.arrayDifference)((0, utils_1.deduplicate)(ruleTypeAttributes), ruleTypes.map((ruleType) => ruleType.rule_attribute));
+        if (invalidRuleTypes.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot find RuleTypes with rule_attribute - ${invalidRuleTypes.join(", ")}`);
+        }
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        const priceListsToCreate = data.map((priceListData) => {
+            const id = (0, utils_1.generateEntityId)(priceListData.id, price_list_1.PriceListIdPrefix);
+            const { prices = [], rules = {}, ...rest } = priceListData;
+            (0, _utils_1.validatePriceListDates)(priceListData);
+            const priceListRules = Object.entries(rules).map(([attribute, value]) => {
+                const ruleType = ruleTypeMap.get(attribute);
+                return {
+                    price_list_id: id,
+                    rule_type_id: ruleType.id,
+                    price_list_rule_values: value.map((v) => ({ value: v })),
+                };
             });
-            priceList.prices.map((price) => {
-                eventsData.prices.push({
-                    id: price.id,
-                });
-                price.price_rules.map((priceRule) => {
-                    eventsData.priceRules.push({
-                        id: priceRule.id,
-                    });
+            const pricesData = prices.map((price) => {
+                const priceRules = Object.entries(price.rules ?? {}).map(([ruleAttribute, ruleValue]) => {
+                    return {
+                        price_set_id: price.price_set_id,
+                        rule_type_id: ruleTypeMap.get(ruleAttribute)?.id,
+                        value: ruleValue,
+                    };
                 });
+                return {
+                    price_list_id: id,
+                    title: "test",
+                    rules_count: Object.keys(price.rules ?? {}).length,
+                    price_rules: priceRules,
+                    ...price,
+                };
             });
-            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 {
+                id,
+                ...rest,
+                rules_count: Object.keys(rules).length,
+                price_list_rules: priceListRules,
+                prices: pricesData,
+            };
         });
-        return priceLists;
+        return await this.priceListService_.create(priceListsToCreate, sharedContext);
     }
     async updatePriceLists_(data, sharedContext = {}) {
-        const existingPriceLists = await this.priceListService_.list({ id: data.map((d) => d.id) }, {}, sharedContext);
-        if (existingPriceLists.length !== data.length) {
-            const diff = (0, utils_1.arrayDifference)(data.map((d) => d.id), existingPriceLists.map((p) => p.id));
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price lists with ids: '${diff.join(", ")}' not found`);
+        const updatedPriceLists = [];
+        const ruleAttributes = [];
+        const priceListIds = [];
+        for (const priceListData of data) {
+            if (typeof priceListData.rules === "object") {
+                ruleAttributes.push(...Object.keys(priceListData.rules));
+                priceListIds.push(priceListData.id);
+            }
         }
-        const normalizedData = this.normalizePriceListDate(data).map((priceList) => {
-            const entry = {
-                ...priceList,
-                rules: undefined,
-                price_list_rules: undefined,
+        const existingPriceLists = await this.listPriceLists({ id: priceListIds }, { relations: ["price_list_rules"] }, sharedContext);
+        const priceListRuleIds = existingPriceLists
+            .map((pl) => (pl.price_list_rules || []).map((plr) => plr.id))
+            .flat();
+        const existingPriceListRules = await this.listPriceListRules({ id: priceListRuleIds }, {}, sharedContext);
+        if (existingPriceListRules.length) {
+            await this.deletePriceListRules(existingPriceListRules.map((plr) => plr.id), sharedContext);
+        }
+        const ruleTypes = await this.listRuleTypes({ rule_attribute: ruleAttributes }, { take: null }, sharedContext);
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        for (const priceListData of data) {
+            const { rules, ...priceListOnlyData } = priceListData;
+            const updatePriceListData = {
+                ...priceListOnlyData,
             };
-            if (typeof priceList.rules === "object") {
-                const cleanRules = priceList.rules
-                    ? (0, utils_1.removeNullish)(priceList.rules)
-                    : {};
-                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);
-                });
-                entry.price_list_rules = Array.from(rulesDataMap.values());
-                entry.rules_count = numberOfRules;
+            (0, _utils_1.validatePriceListDates)(updatePriceListData);
+            if (typeof rules === "object") {
+                updatePriceListData.rules_count = Object.keys(rules).length;
             }
-            return entry;
-        });
-        const { entities } = await this.priceListService_.upsertWithReplace(normalizedData, {
-            relations: ["price_list_rules"],
-        });
-        return entities;
+            const [updatedPriceList] = (await this.priceListService_.update([updatePriceListData], sharedContext));
+            updatedPriceLists.push(updatedPriceList);
+            for (const [ruleAttribute, ruleValues = []] of Object.entries(rules || {})) {
+                let ruleType = ruleTypeMap.get(ruleAttribute);
+                if (!ruleType) {
+                    ;
+                    [ruleType] = await this.createRuleTypes([{ name: ruleAttribute, rule_attribute: ruleAttribute }], sharedContext);
+                    ruleTypeMap.set(ruleAttribute, ruleType);
+                }
+                const [priceListRule] = await this.priceListRuleService_.create([
+                    {
+                        price_list_id: updatedPriceList.id,
+                        rule_type_id: ruleType?.id,
+                    },
+                ], sharedContext);
+                for (const ruleValue of ruleValues) {
+                    await this.priceListRuleValueService_.create([{ price_list_rule_id: priceListRule.id, value: ruleValue }], sharedContext);
+                }
+            }
+        }
+        return updatedPriceLists;
     }
     async updatePriceListPrices_(data, 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)
+        const ruleTypeAttributes = [];
+        const priceListIds = [];
+        const priceIds = [];
+        const priceSetIds = data
+            .map((d) => d.prices.map((price) => price.price_set_id))
             .flat();
+        for (const priceListData of data) {
+            priceListIds.push(priceListData.price_list_id);
+            for (const price of priceListData.prices) {
+                priceIds.push(price.id);
+                ruleTypeAttributes.push(...Object.keys(price.rules || {}));
+            }
+        }
+        const prices = await this.listPrices({ id: priceIds }, { take: null, relations: ["price_rules"] }, sharedContext);
+        const priceMap = new Map(prices.map((price) => [price.id, price]));
+        const ruleTypes = await this.listRuleTypes({ rule_attribute: ruleTypeAttributes }, { take: null }, sharedContext);
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        const priceSets = await this.list({ id: priceSetIds }, { relations: ["rule_types"] }, sharedContext);
+        const priceSetRuleTypeMap = priceSets.reduce((acc, curr) => {
+            const priceSetRuleAttributeSet = acc.get(curr.id) || new Set();
+            for (const rt of curr.rule_types ?? []) {
+                priceSetRuleAttributeSet.add(rt.rule_attribute);
+            }
+            acc.set(curr.id, priceSetRuleAttributeSet);
+            return acc;
+        }, new Map());
+        const ruleTypeErrors = [];
+        for (const priceListData of data) {
+            for (const price of priceListData.prices) {
+                for (const ruleAttribute of Object.keys(price.rules ?? {})) {
+                    if (!priceSetRuleTypeMap.get(price.price_set_id)?.has(ruleAttribute)) {
+                        ruleTypeErrors.push(`rule_attribute "${ruleAttribute}" in price set ${price.price_set_id}`);
+                    }
+                }
+            }
+        }
+        if (ruleTypeErrors.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid rule type configuration: Price set rules doesn't exist for ${ruleTypeErrors.join(", ")}`);
+        }
+        const priceLists = await this.listPriceLists({ id: priceListIds }, { take: null }, sharedContext);
         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,
+                    rule_type_id: ruleTypeMap.get(ruleAttribute).id,
+                    value: ruleValue,
+                    price_id: price.id,
+                })));
+                pricesToUpdate.push({
+                    ...rest,
+                    rules_count: Object.keys(rules).length,
+                });
+                priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id));
+            }
         }
-        const { entities } = await this.priceService_.upsertWithReplace(pricesToUpsert, { relations: ["price_rules"] }, sharedContext);
-        return entities;
+        const [_deletedPriceRule, _createdPriceRule, updatedPrices] = await (0, utils_1.promiseAll)([
+            this.priceRuleService_.delete(priceRuleIdsToDelete),
+            this.priceRuleService_.create(priceRulesToCreate),
+            this.priceService_.update(pricesToUpdate),
+        ]);
+        return updatedPrices;
     }
     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) }, { 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 ruleTypeAttributes = [];
+        const priceListIds = [];
+        const priceSetIds = [];
+        for (const priceListData of data) {
+            priceListIds.push(priceListData.price_list_id);
+            for (const price of priceListData.prices) {
+                ruleTypeAttributes.push(...Object.keys(price.rules || {}));
+                priceSetIds.push(price.price_set_id);
+            }
+        }
+        const ruleTypes = await this.listRuleTypes({ rule_attribute: ruleTypeAttributes }, { take: null }, sharedContext);
+        const priceSets = await this.list({ id: priceSetIds }, { relations: ["rule_types"] }, sharedContext);
+        const priceSetRuleTypeMap = priceSets.reduce((acc, curr) => {
+            const priceSetRuleAttributeSet = acc.get(curr.id) || new Set();
+            for (const rt of curr.rule_types ?? []) {
+                priceSetRuleAttributeSet.add(rt.rule_attribute);
+            }
+            acc.set(curr.id, priceSetRuleAttributeSet);
+            return acc;
+        }, new Map());
+        const ruleTypeErrors = [];
+        for (const priceListData of data) {
+            for (const price of priceListData.prices) {
+                for (const rule_attribute of Object.keys(price.rules ?? {})) {
+                    if (!priceSetRuleTypeMap.get(price.price_set_id)?.has(rule_attribute)) {
+                        ruleTypeErrors.push(`rule_attribute "${rule_attribute}" in price set ${price.price_set_id}`);
+                    }
+                }
+            }
+        }
+        if (ruleTypeErrors.length) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid rule type configuration: Price set rules doesn't exist for ${ruleTypeErrors.join(", ")}`);
+        }
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        const priceLists = await this.listPriceLists({ id: priceListIds }, {}, sharedContext);
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
-        pricesToUpsert.forEach((price) => {
-            const priceList = priceListMap.get(price.price_list_id);
+        const pricesToCreate = [];
+        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: ${price.price_list_id} not found`);
+                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);
-        _utils_1.eventBuilders.createdPrice({
-            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: performedActions.created[_models_1.PriceRule.name] ?? [],
-            sharedContext,
-        });
-        _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;
+            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_set_id: priceData.price_set_id,
+                        rule_type_id: ruleTypeMap.get(ruleAttribute)?.id,
+                        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);
+        }
+        return await this.priceService_.create(pricesToCreate, sharedContext);
     }
     async setPriceListRules_(data, sharedContext = {}) {
         // TODO: re think this method
-        const priceLists = await this.priceListService_.list({ id: data.map((d) => d.price_list_id) }, {
-            relations: ["price_list_rules"],
-        }, sharedContext);
-        const rulesMap = new Map();
-        data.forEach((rule) => {
-            if (!rulesMap.has(rule.price_list_id)) {
-                rulesMap.set(rule.price_list_id, []);
+        const priceLists = await this.priceListService_.list({ id: data.map((d) => d.price_list_id) }, { relations: ["price_list_rules", "price_list_rules.rule_type"] }, sharedContext);
+        const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
+        const ruleTypes = await this.listRuleTypes({ rule_attribute: data.map((d) => Object.keys(d.rules)).flat() }, { take: null });
+        const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
+        const ruleIdsToUpdate = [];
+        const rulesToCreate = [];
+        const priceRuleValues = new Map();
+        for (const { price_list_id: priceListId, rules } 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`);
             }
-            Object.entries(rule.rules).forEach(([key, value]) => {
-                rulesMap.get(rule.price_list_id).push([key, value]);
+            const priceListRulesMap = new Map(priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p]));
+            const priceListRuleValues = new Map();
+            Object.entries(rules).map(async ([key, value]) => {
+                const ruleType = ruleTypeMap.get(key);
+                if (!ruleType) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Rule type with attribute: ${key} not found`);
+                }
+                const rule = priceListRulesMap.get(key);
+                priceListRuleValues.set(ruleType.id, Array.isArray(value) ? value : [value]);
+                if (!rule) {
+                    rulesToCreate.push({
+                        rule_type_id: ruleType.id,
+                        price_list_id: priceListId,
+                    });
+                }
+                else {
+                    ruleIdsToUpdate.push(rule.id);
+                }
             });
-        });
-        const priceListsUpsert = priceLists
-            .map((priceList) => {
-            const allRules = new Map(priceList.price_list_rules
-                .toArray()
-                .map((r) => [r.attribute, r.value]));
-            const rules = rulesMap.get(priceList.id);
-            if (!rules?.length) {
-                return;
+            priceRuleValues.set(priceListId, priceListRuleValues);
+        }
+        const [createdRules, priceListValuesToDelete] = await (0, utils_1.promiseAll)([
+            this.priceListRuleService_.create(rulesToCreate),
+            this.priceListRuleValueService_.list({ price_list_rule_id: ruleIdsToUpdate }, { take: null }),
+        ]);
+        const priceListRuleValuesToCreate = [];
+        for (const { id, price_list_id, rule_type_id } of createdRules) {
+            const ruleValues = priceRuleValues.get(price_list_id);
+            if (!ruleValues) {
+                continue;
             }
-            rules.forEach(([key, value]) => {
-                allRules.set(key, value);
+            const values = ruleValues.get(rule_type_id);
+            if (!values) {
+                continue;
+            }
+            values.forEach((v) => {
+                priceListRuleValuesToCreate.push({
+                    price_list_rule_id: id,
+                    value: v,
+                });
             });
-            return {
-                ...priceList,
-                rules_count: allRules.size,
-                price_list_rules: Array.from(allRules).map(([attribute, value]) => ({
-                    attribute,
-                    value,
-                })),
-            };
-        })
-            .filter(Boolean);
-        const { entities } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
-        return entities;
+        }
+        await (0, utils_1.promiseAll)([
+            this.priceListRuleValueService_.delete(priceListValuesToDelete.map((p) => p.id), sharedContext),
+            this.priceListRuleValueService_.create(priceListRuleValuesToCreate, sharedContext),
+        ]);
+        return priceLists;
     }
     async removePriceListRules_(data, sharedContext = {}) {
-        // TODO: re think this method
-        const priceLists = await this.priceListService_.list({ id: data.map((d) => d.price_list_id) }, {
-            relations: ["price_list_rules"],
-        }, sharedContext);
-        const rulesMap = new Map();
-        data.forEach((rule) => {
-            if (!rulesMap.has(rule.price_list_id)) {
-                rulesMap.set(rule.price_list_id, []);
-            }
-            rule.rules.forEach((key) => {
-                rulesMap.get(rule.price_list_id).push([key, undefined]);
-            });
-        });
-        const priceListsUpsert = priceLists
-            .map((priceList) => {
-            const allRules = new Map(priceList.price_list_rules
-                .toArray()
-                .map((r) => [r.attribute, r.value]));
-            const rules = rulesMap.get(priceList.id);
-            if (!rules?.length) {
-                return;
+        const priceLists = await this.priceListService_.list({ id: data.map((d) => d.price_list_id) }, { relations: ["price_list_rules", "price_list_rules.rule_type"] }, sharedContext);
+        const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
+        const idsToDelete = [];
+        for (const { price_list_id: priceListId, rules } 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`);
             }
-            rules.forEach(([key, value]) => {
-                allRules.set(key, value);
+            const priceListRulesMap = new Map(priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p]));
+            rules.map(async (rule_attribute) => {
+                const rule = priceListRulesMap.get(rule_attribute);
+                if (rule) {
+                    idsToDelete.push(rule.id);
+                }
             });
-            return {
-                ...priceList,
-                rules_count: allRules.size,
-                price_list_rules: Array.from(allRules)
-                    .map(([attribute, value]) => ({
-                    attribute,
-                    value,
-                }))
-                    .filter((r) => !!r.value),
-            };
-        })
-            .filter(Boolean);
-        const { entities } = await this.priceListService_.upsertWithReplace(priceListsUpsert, { relations: ["price_list_rules"] }, sharedContext);
-        return entities;
-    }
-    normalizePriceListDate(data) {
-        return data.map((priceListData) => {
-            (0, _utils_1.validatePriceListDates)(priceListData);
-            if (!!priceListData.starts_at) {
-                priceListData.starts_at = (0, utils_1.GetIsoStringFromDate)(priceListData.starts_at);
-            }
-            if (!!priceListData.ends_at) {
-                priceListData.ends_at = (0, utils_1.GetIsoStringFromDate)(priceListData.ends_at);
-            }
-            return priceListData;
-        });
-    }
-    normalizePriceSetConfig(config) {
-        return {
-            options: {
-                populateWhere: { prices: { price_list_id: null } },
-            },
-            ...config,
-        };
+        }
+        await this.priceListRuleService_.delete(idsToDelete);
+        return priceLists;
     }
 }
 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
-    ,
+    (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "listPriceSets", null);
+], PricingModuleService.prototype, "list", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-expect-error
-    ,
+    (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "listAndCountPriceSets", null);
+], PricingModuleService.prototype, "listAndCount", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -779,55 +820,62 @@ __decorate([
 ], PricingModuleService.prototype, "calculatePrices", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "createPriceSets", null);
+], PricingModuleService.prototype, "create", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "upsertPriceSets", null);
+], PricingModuleService.prototype, "upsert", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "updatePriceSets", null);
+], PricingModuleService.prototype, "update", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "updatePriceSets_", null);
+], PricingModuleService.prototype, "update_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "addRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "addPrices", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "removeRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    (0, utils_1.EmitEvents)()
-    // @ts-ignore
-    ,
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "createPriceLists", null);
 __decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_")
-    // @ts-ignore
-    ,
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
@@ -839,79 +887,70 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "updatePriceListPrices", null);
+], PricingModuleService.prototype, "createPriceListRules", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "removePrices", null);
+], PricingModuleService.prototype, "createPriceListRules_", null);
 __decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    (0, utils_1.EmitEvents)(),
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "addPriceListPrices", null);
+], PricingModuleService.prototype, "updatePriceListRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "setPriceListRules", null);
+], PricingModuleService.prototype, "updatePriceListPrices", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "removePriceListRules", null);
+], PricingModuleService.prototype, "removePrices", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    (0, utils_1.EmitEvents)(),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "createPricePreferences", null);
+], PricingModuleService.prototype, "addPriceListPrices", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "upsertPricePreferences", null);
+], PricingModuleService.prototype, "setPriceListRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "updatePricePreferences", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "createPricePreferences_", null);
+], PricingModuleService.prototype, "removePriceListRules", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "updatePricePreferences_", null);
+], PricingModuleService.prototype, "create_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "createPriceSets_", null);
+], PricingModuleService.prototype, "addRules_", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -963,31 +1002,3 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "removePriceListRules_", null);
-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);
-    const currencyPreference = preferences.find((p) => p.attribute === "currency_code" && p.value === currencyCode);
-    if (regionRule && regionPreference) {
-        return regionPreference.is_tax_inclusive;
-    }
-    if (currencyPreference) {
-        return currencyPreference.is_tax_inclusive;
-    }
-    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));
-};