@medusajs/pricing 0.1.13-preview-20240701060617 → 0.1.13-preview-20240701074916

package/dist/services/pricing-module.js

@@ -17,32 +17,25 @@ const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
 const _utils_1 = require("../utils");
 const joiner_config_1 = require("../joiner-config");
-const price_list_1 = require("../models/price-list");
-const price_set_1 = require("../models/price-set");
 const generateMethodForModels = {
     PriceSet: _models_1.PriceSet,
     PriceList: _models_1.PriceList,
     PriceListRule: _models_1.PriceListRule,
-    PriceListRuleValue: _models_1.PriceListRuleValue,
     PriceRule: _models_1.PriceRule,
     Price: _models_1.Price,
-    RuleType: _models_1.RuleType,
 };
 class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
-    constructor({ baseRepository, pricingRepository, ruleTypeService, priceSetService, priceRuleService, priceService, priceListService, priceListRuleService, priceListRuleValueService, }, moduleDeclaration) {
+    constructor({ baseRepository, pricingRepository, priceSetService, priceRuleService, priceService, priceListService, priceListRuleService, }, 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.priceService_ = priceService;
         this.priceListService_ = priceListService;
         this.priceListRuleService_ = priceListRuleService;
-        this.priceListRuleValueService_ = priceListRuleValueService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
@@ -63,18 +56,19 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     async listPriceSets(filters = {}, config = {}, sharedContext = {}) {
         const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
         const priceSets = await super.listPriceSets(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;
-            }
+        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);
+        for (const calculatedPrice of calculatedPrices) {
+            const priceSet = priceSetMap.get(calculatedPrice.id);
+            priceSet.calculated_price = calculatedPrice;
         }
         return priceSets;
     }
@@ -82,18 +76,19 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     async listAndCountPriceSets(filters = {}, config = {}, sharedContext = {}) {
         const pricingContext = this.setupCalculatedPriceConfig_(filters, config);
         const [priceSets, count] = await super.listAndCountPriceSets(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;
-            }
+        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);
+        for (const calculatedPrice of calculatedPrices) {
+            const priceSet = priceSetMap.get(calculatedPrice.id);
+            priceSet.calculated_price = calculatedPrice;
         }
         return [priceSets, count];
     }
@@ -145,12 +140,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         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) }, {
-            relations: [
-                "rule_types",
-                "prices",
-                "price_rules",
-                "prices.price_rules",
-            ],
+            relations: ["prices", "prices.price_rules"],
         }, sharedContext);
         // Ensure the output to be in the same order as the input
         const results = priceSets.map((priceSet) => {
@@ -190,22 +180,12 @@ 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, 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());
+    async normalizeUpdateData(data) {
         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,
+                        attribute,
                         value,
                     };
                 });
@@ -225,10 +205,9 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         });
     }
     async updatePriceSets_(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, sharedContext);
+        const normalizedData = await this.normalizeUpdateData(data);
         const prices = normalizedData.flatMap((priceSet) => priceSet.prices || []);
         const { entities: upsertedPrices } = await this.priceService_.upsertWithReplace(prices, { relations: ["price_rules"] }, sharedContext);
         const priceSetsToUpsert = normalizedData.map((priceSet) => {
@@ -287,49 +266,34 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     }
     async createPriceSets_(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const ruleAttributes = (0, utils_1.deduplicate)(data
-            .map((d) => d.prices?.map((ma) => Object.keys(ma?.rules ?? {})).flat() ?? [])
-            .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 prices with rule attribute: ${invalidRuleAttributes.join(", ")}`);
-        }
         const toCreate = input.map((inputData) => {
-            const id = (0, utils_1.generateEntityId)(inputData.id, price_set_1.PriceSetIdPrefix);
-            const { prices, ...rest } = inputData;
-            let pricesData = [];
-            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);
-                    });
-                    return {
-                        ...rest,
-                        title: "", // TODO: accept title
-                        rules_count: numberOfRules,
-                        price_rules: Array.from(rulesDataMap.values()),
+            const entry = {
+                ...inputData,
+            };
+            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,
-                id,
-                prices: pricesData,
-            };
+                return {
+                    ...rest,
+                    rules_count: numberOfRules,
+                    price_rules: Array.from(rulesDataMap.values()),
+                };
+            });
+            entry.prices = pricesData;
+            return entry;
         });
         // Bulk create price sets
         const createdPriceSets = await this.priceSetService_.create(toCreate, sharedContext);
@@ -368,36 +332,24 @@ 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) }, { relations: ["rule_types"] }, sharedContext);
+        const priceSets = await this.listPriceSets({ id: input.map((d) => d.priceSetId) }, {}, sharedContext);
         const priceSetMap = new Map(priceSets.map((p) => [p.id, p]));
-        const ruleTypeMap = new Map(priceSets.map((priceSet) => [
-            priceSet.id,
-            new Map(priceSet.rule_types?.map((rt) => [rt.rule_attribute, rt]) ?? []),
-        ]));
-        input.forEach(({ priceSetId, prices }) => {
+        input.forEach(({ priceSetId }) => {
             const priceSet = priceSetMap.get(priceSetId);
             if (!priceSet) {
                 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 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,
+                attribute: attribute,
                 value,
             }));
             return {
                 ...price,
                 price_set_id: priceSetId,
-                title: "test", // TODO: accept title
                 rules_count: numberOfRules,
                 price_rules: priceRules,
             };
@@ -434,56 +386,52 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return prices;
     }
     async createPriceLists_(data, sharedContext = {}) {
-        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));
-            }
-        }
-        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 })),
-                };
-            });
-            const pricesData = prices.map((price) => {
-                const priceRules = Object.entries(price.rules ?? {}).map(([ruleAttribute, ruleValue]) => {
+        const normalized = this.normalizePriceListDate(data);
+        const priceListsToCreate = normalized.map((priceListData) => {
+            const entry = {
+                ...priceListData,
+                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 {
-                        price_set_id: price.price_set_id,
-                        rule_type_id: ruleTypeMap.get(ruleAttribute)?.id,
-                        value: ruleValue,
+                        ...rest,
+                        rules_count: numberOfRules,
+                        price_rules: Array.from(rulesDataMap.values()),
                     };
                 });
-                return {
-                    price_list_id: id,
-                    title: "test",
-                    rules_count: Object.keys(price.rules ?? {}).length,
-                    price_rules: priceRules,
-                    ...price,
-                };
-            });
-            return {
-                id,
-                ...rest,
-                rules_count: Object.keys(rules).length,
-                price_list_rules: priceListRules,
-                prices: pricesData,
-            };
+                entry.prices = pricesData;
+            }
+            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);
         /**
@@ -537,71 +485,52 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         return priceLists;
     }
     async updatePriceLists_(data, sharedContext = {}) {
-        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 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 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 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,
+        const normalizedData = this.normalizePriceListDate(data).map((priceList) => {
+            const entry = {
+                ...priceList,
+                rules: undefined,
+                price_list_rules: undefined,
             };
-            (0, _utils_1.validatePriceListDates)(updatePriceListData);
-            if (typeof rules === "object") {
-                updatePriceListData.rules_count = Object.keys(rules).length;
-            }
-            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);
-                }
+            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;
             }
-        }
-        return updatedPriceLists;
+            return entry;
+        });
+        const { entities } = await this.priceListService_.upsertWithReplace(normalizedData, {
+            relations: ["price_list_rules"],
+        });
+        return entities;
     }
     async updatePriceListPrices_(data, sharedContext = {}) {
-        const ruleTypeAttributes = [];
         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);
-                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 priceLists = await this.listPriceLists({ id: priceListIds }, { take: null }, sharedContext);
         const priceListMap = new Map(priceLists.map((p) => [p.id, p]));
         const pricesToUpdate = [];
@@ -618,7 +547,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 const priceRules = price.price_rules;
                 priceRulesToCreate.push(...Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({
                     price_set_id,
-                    rule_type_id: ruleTypeMap.get(ruleAttribute).id,
+                    attribute: ruleAttribute,
                     value: ruleValue,
                     price_id: price.id,
                 })));
@@ -640,18 +569,10 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
         await this.priceService_.delete(ids, sharedContext);
     }
     async addPriceListPrices_(data, sharedContext = {}) {
-        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 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]));
         const pricesToCreate = [];
@@ -665,8 +586,8 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
                 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,
+                        price_list_id: priceData.price_set_id,
+                        attribute: ruleAttribute,
                         value: ruleValue,
                     };
                 });
@@ -708,85 +629,95 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.MedusaService(generat
     }
     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", "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`);
+        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 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);
-                }
+            Object.entries(rule.rules).forEach(([key, value]) => {
+                rulesMap.get(rule.price_list_id).push([key, value]);
             });
-            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;
-            }
-            const values = ruleValues.get(rule_type_id);
-            if (!values) {
-                continue;
+        });
+        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;
             }
-            values.forEach((v) => {
-                priceListRuleValuesToCreate.push({
-                    price_list_rule_id: id,
-                    value: v,
-                });
+            rules.forEach(([key, value]) => {
+                allRules.set(key, value);
             });
-        }
-        await (0, utils_1.promiseAll)([
-            this.priceListRuleValueService_.delete(priceListValuesToDelete.map((p) => p.id), sharedContext),
-            this.priceListRuleValueService_.create(priceListRuleValuesToCreate, sharedContext),
-        ]);
-        return priceLists;
+            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;
     }
     async removePriceListRules_(data, sharedContext = {}) {
-        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`);
+        // 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 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);
-                }
+            rule.rules.forEach((key) => {
+                rulesMap.get(rule.price_list_id).push([key, undefined]);
             });
-        }
-        await this.priceListRuleService_.delete(idsToDelete);
-        return priceLists;
+        });
+        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;
+            }
+            rules.forEach(([key, value]) => {
+                allRules.set(key, value);
+            });
+            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;
+        });
     }
 }
 exports.default = PricingModuleService;