@medusajs/pricing 0.1.10 → 0.1.11

package/dist/services/pricing-module.js

@@ -17,32 +17,30 @@ 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_set_1 = require("../models/price-set");
+const price_list_1 = require("../models/price-list");
 const generateMethodForModels = [
-    _models_1.MoneyAmount,
     _models_1.PriceList,
     _models_1.PriceListRule,
     _models_1.PriceListRuleValue,
     _models_1.PriceRule,
-    _models_1.PriceSetMoneyAmount,
-    _models_1.PriceSetMoneyAmountRules,
+    _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, moneyAmountService, ruleTypeService, priceSetService, priceSetMoneyAmountRulesService, priceRuleService, priceSetRuleTypeService, priceSetMoneyAmountService, priceListService, priceListRuleService, priceListRuleValueService, }, moduleDeclaration) {
+    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.moneyAmountService_ = moneyAmountService;
         this.ruleTypeService_ = ruleTypeService;
         this.priceSetService_ = priceSetService;
-        this.priceSetMoneyAmountRulesService_ = priceSetMoneyAmountRulesService;
         this.ruleTypeService_ = ruleTypeService;
         this.priceRuleService_ = priceRuleService;
         this.priceSetRuleTypeService_ = priceSetRuleTypeService;
-        this.priceSetMoneyAmountService_ = priceSetMoneyAmountService;
+        this.priceService_ = priceService;
         this.priceListService_ = priceListService;
         this.priceListRuleService_ = priceListRuleService;
         this.priceListRuleValueService_ = priceListRuleValueService;
@@ -76,14 +74,14 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 original_amount: parseInt(originalPrice?.amount || "") || null,
                 currency_code: calculatedPrice?.currency_code || null,
                 calculated_price: {
-                    money_amount_id: calculatedPrice?.id || null,
+                    id: calculatedPrice?.id || null,
                     price_list_id: calculatedPrice?.price_list_id || null,
                     price_list_type: calculatedPrice?.price_list_type || null,
                     min_quantity: parseInt(calculatedPrice?.min_quantity || "") || null,
                     max_quantity: parseInt(calculatedPrice?.max_quantity || "") || null,
                 },
                 original_price: {
-                    money_amount_id: originalPrice?.id || null,
+                    id: originalPrice?.id || null,
                     price_list_id: originalPrice?.price_list_id || null,
                     price_list_type: originalPrice?.price_list_type || null,
                     min_quantity: parseInt(originalPrice?.min_quantity || "") || null,
@@ -96,18 +94,19 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         const priceSets = await this.create_(input, sharedContext);
-        const dbPriceSets = await this.list({ id: priceSets.filter((p) => !!p).map((p) => p.id) }, {
-            relations: ["rule_types", "money_amounts", "price_rules"],
-        }, sharedContext);
-        return (Array.isArray(data) ? dbPriceSets : dbPriceSets[0]);
+        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 Array.isArray(data) ? results : results[0];
     }
     async create_(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
         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 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;
@@ -123,68 +122,62 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         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(", ")}`);
         }
-        // Bulk create price sets
-        const priceSetData = data.map(({ rules, prices, ...rest }) => rest);
-        const createdPriceSets = await this.priceSetService_.create(priceSetData, sharedContext);
-        // Price set rule types
-        const ruleTypeData = data.flatMap((item, index) => item.rules?.map((rule) => ({
-            rule_type: ruleTypeMap.get(rule.rule_attribute),
-            price_set: createdPriceSets[index],
-        })) || []);
-        if (ruleTypeData.length > 0) {
-            await this.priceSetRuleTypeService_.create(ruleTypeData, sharedContext);
-        }
-        // Money amounts
-        const moneyAmountData = data.flatMap((item) => item.prices || []);
-        const createdMoneyAmounts = await this.moneyAmountService_.create(moneyAmountData, sharedContext);
-        let moneyAmountIndex = 0;
-        const priceSetMoneyAmountData = [];
-        const priceRulesData = [];
-        for (const [index, item] of data.entries()) {
-            for (const ma of item.prices || []) {
-                const cleanRules = ma.rules ? (0, utils_1.removeNullish)(ma.rules) : {};
-                const numberOfRules = Object.entries(cleanRules).length;
-                const priceSetMoneyAmount = {
-                    price_set: createdPriceSets[index],
-                    money_amount: createdMoneyAmounts[moneyAmountIndex++],
-                    title: "test",
-                    rules_count: numberOfRules,
+        const ruleSetRuleTypeToCreateMap = new Map();
+        const toCreate = input.map((inputData) => {
+            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,
                 };
-                priceSetMoneyAmountData.push(priceSetMoneyAmount);
-                for (const [k, v] of Object.entries(cleanRules)) {
-                    priceRulesData.push({
-                        price_set_money_amount: null,
-                        rule_type: ruleTypeMap.get(k),
-                        price_set: createdPriceSets[index],
-                        value: v,
-                        price_list_id: "test",
+                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);
                     });
-                }
-            }
-        }
-        // Bulk create price set money amounts
-        const createdPriceSetMoneyAmounts = await this.priceSetMoneyAmountService_.create(priceSetMoneyAmountData, sharedContext);
-        // Update price set money amount references
-        for (let i = 0, j = 0; i < priceSetMoneyAmountData.length; i++) {
-            const rulesCount = priceSetMoneyAmountData[i].rules_count;
-            for (let k = 0; k < rulesCount; k++, j++) {
-                ;
-                priceRulesData[j].price_set_money_amount =
-                    createdPriceSetMoneyAmounts[i];
+                    return {
+                        ...rest,
+                        title: "test",
+                        rules_count: numberOfRules,
+                        price_rules: Array.from(rulesDataMap.values()),
+                    };
+                });
             }
-        }
-        // Price rules
-        if (priceRulesData.length > 0) {
-            await this.priceRuleService_.create(priceRulesData, sharedContext);
+            return {
+                ...rest,
+                id,
+                prices: pricesData,
+            };
+        });
+        // Bulk create price sets
+        const createdPriceSets = await this.priceSetService_.create(toCreate, sharedContext);
+        if (ruleSetRuleTypeToCreateMap.size) {
+            await this.priceSetRuleTypeService_.create(Array.from(ruleSetRuleTypeToCreateMap.values()), sharedContext);
         }
         return createdPriceSets;
     }
     async addRules(data, sharedContext = {}) {
         const inputs = Array.isArray(data) ? data : [data];
         const priceSets = await this.addRules_(inputs, sharedContext);
-        return await this.list({ id: priceSets.map(({ id }) => id) }, {
-            relations: ["rule_types"],
-        });
+        return await this.list({ id: priceSets.map(({ id }) => id) }, { relations: ["rule_types"] });
     }
     async addRules_(inputs, sharedContext = {}) {
         const priceSets = await this.priceSetService_.list({ id: inputs.map((d) => d.priceSetId) }, { relations: ["rule_types"] }, sharedContext);
@@ -201,7 +194,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
         const ruleTypes = await this.ruleTypeService_.list({
             rule_attribute: inputs
-                .map((d) => d.rules.map((r) => r.attribute))
+                .map((data) => data.rules.map((r) => r.attribute))
                 .flat(),
         }, { take: null }, sharedContext);
         const ruleTypeMap = new Map(ruleTypes.map((rt) => [rt.rule_attribute, rt]));
@@ -215,15 +208,14 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             ].join(", ")}`);
         }
         const priceSetRuleTypesCreate = [];
-        inputs.forEach((d) => {
-            const priceSet = priceSetMap.get(d.priceSetId);
-            for (const r of d.rules) {
-                if (priceSetRuleTypeMap.get(d.priceSetId).has(r.attribute)) {
+        inputs.forEach((data) => {
+            for (const rule of data.rules) {
+                if (priceSetRuleTypeMap.get(data.priceSetId).has(rule.attribute)) {
                     continue;
                 }
                 priceSetRuleTypesCreate.push({
-                    rule_type: ruleTypeMap.get(r.attribute),
-                    price_set: priceSet,
+                    rule_type_id: ruleTypeMap.get(rule.attribute).id,
+                    price_set_id: priceSetMap.get(data.priceSetId).id,
                 });
             }
         });
@@ -233,7 +225,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async addPrices(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
         await this.addPrices_(input, sharedContext);
-        return (await this.list({ id: input.map((d) => d.priceSetId) }, { relations: ["money_amounts"] }, sharedContext));
+        return await this.list({ id: input.map((d) => d.priceSetId) }, { relations: ["prices"] }, sharedContext);
     }
     async addPrices_(input, sharedContext = {}) {
         const priceSets = await this.list({ id: input.map((d) => d.priceSetId) }, { relations: ["rule_types"] }, sharedContext);
@@ -255,33 +247,26 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Rule types don't exist for: ${invalidRuleAttributes.join(", ")}`);
             }
         });
-        // Money amounts
-        const moneyAmountsBulkData = input.flatMap((entry) => entry.prices);
-        const createdMoneyAmounts = await this.moneyAmountService_.create(moneyAmountsBulkData, sharedContext);
-        // Price set money amounts
-        let maCursor = 0;
-        const priceSetMoneyAmountsBulkData = input.flatMap(({ priceSetId, prices }) => prices.map(() => {
-            const ma = createdMoneyAmounts[maCursor];
-            const numberOfRules = Object.entries(prices[maCursor]?.rules ?? {}).length;
-            maCursor++;
+        const pricesToCreate = input.flatMap(({ priceSetId, prices }) => prices.map((price) => {
+            const numberOfRules = Object.entries(price?.rules ?? {}).length;
             return {
-                price_set: priceSetId,
-                money_amount: ma,
+                ...price,
+                price_set_id: priceSetId,
                 title: "test",
                 rules_count: numberOfRules,
             };
         }));
-        const createdPriceSetMoneyAmounts = await this.priceSetMoneyAmountService_.create(priceSetMoneyAmountsBulkData, sharedContext);
+        const createdPrices = await this.priceService_.create(pricesToCreate, sharedContext);
         // Price rules
         let rulesCursor = 0;
         const priceRulesBulkData = input.flatMap(({ priceSetId, prices }) => prices.flatMap((ma) => {
             const rules = ma.rules ?? {};
-            const priceSetMoneyAmount = createdPriceSetMoneyAmounts[rulesCursor];
+            const price = createdPrices[rulesCursor];
             rulesCursor++;
             return Object.entries(rules).map(([k, v]) => ({
-                price_set_money_amount: priceSetMoneyAmount,
+                price_id: price.id,
                 rule_type_id: ruleTypeMap.get(priceSetId).get(k).id,
-                price_set: priceSetId,
+                price_set_id: priceSetId,
                 value: v,
             }));
         }));
@@ -290,87 +275,24 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
     }
     async removeRules(data, sharedContext = {}) {
-        const priceSets = await this.priceSetService_.list({
-            id: data.map((d) => d.id),
-        }, {}, 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_set_money_amount"],
-            take: null,
-        }, sharedContext);
+        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.priceSetMoneyAmountService_.delete(priceRules.map((pr) => pr.price_set_money_amount.id), sharedContext);
+        await this.priceService_.delete(priceRules.map((pr) => pr.price.id), sharedContext);
     }
     async update(data, sharedContext = {}) {
         const priceSets = await this.priceSetService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(priceSets, {
-            populate: true,
-        });
-    }
-    async createMoneyAmounts(data, sharedContext = {}) {
-        const moneyAmounts = await this.moneyAmountService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(moneyAmounts, {
-            populate: true,
-        });
-    }
-    async updateMoneyAmounts(data, sharedContext = {}) {
-        const moneyAmounts = await this.moneyAmountService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(moneyAmounts, {
-            populate: true,
-        });
-    }
-    async createRuleTypes(data, sharedContext = {}) {
-        const ruleTypes = await this.ruleTypeService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(ruleTypes, {
-            populate: true,
-        });
-    }
-    async updateRuleTypes(data, sharedContext = {}) {
-        const ruleTypes = await this.ruleTypeService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(ruleTypes, {
-            populate: true,
-        });
-    }
-    async createPriceSetMoneyAmountRules(data, sharedContext = {}) {
-        const records = await this.priceSetMoneyAmountRulesService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(records, {
-            populate: true,
-        });
-    }
-    async updatePriceSetMoneyAmountRules(data, sharedContext = {}) {
-        const records = await this.priceSetMoneyAmountRulesService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(records, {
-            populate: true,
-        });
-    }
-    async createPriceRules(data, sharedContext = {}) {
-        const priceRules = await this.priceRuleService_.create(data, sharedContext);
-        return await this.baseRepository_.serialize(priceRules, {
-            populate: true,
-        });
-    }
-    async updatePriceRules(data, sharedContext = {}) {
-        const priceRules = await this.priceRuleService_.update(data, sharedContext);
-        return await this.baseRepository_.serialize(priceRules, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(priceSets, { populate: true });
     }
     async createPriceLists(data, sharedContext = {}) {
         const priceLists = await this.createPriceLists_(data, sharedContext);
-        return await this.baseRepository_.serialize(priceLists, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(priceLists, { populate: true });
     }
     async createPriceLists_(data, sharedContext = {}) {
         const ruleTypeAttributes = [];
@@ -382,74 +304,53 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 ruleTypeAttributes.push(...Object.keys(priceListPriceRules));
             }
         }
-        const ruleTypes = await this.listRuleTypes({ rule_attribute: ruleTypeAttributes }, { take: null });
+        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 = [];
-        for (const priceListData of data) {
-            const { rules = {}, prices = [], ...priceListOnlyData } = priceListData;
+        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);
-            priceListsToCreate.push({
-                ...priceListOnlyData,
-                rules_count: Object.keys(rules).length,
+            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 priceLists = (await this.priceListService_.create(priceListsToCreate));
-        for (let i = 0; i < data.length; i++) {
-            const { rules = {}, prices = [] } = data[i];
-            const priceList = priceLists[i];
-            for (const [ruleAttribute, ruleValues = []] of Object.entries(rules)) {
-                let ruleType = ruleTypeMap.get(ruleAttribute);
-                // Create the rule
-                const [priceListRule] = await this.priceListRuleService_.create([
-                    {
-                        price_list: priceList,
-                        rule_type: ruleType.id,
-                    },
-                ], sharedContext);
-                // Create the values for the rule
-                for (const ruleValue of ruleValues) {
-                    await this.priceListRuleValueService_.create([
-                        {
-                            price_list_rule: priceListRule,
-                            value: ruleValue,
-                        },
-                    ], sharedContext);
-                }
-            }
-            for (const price of prices) {
-                const { price_set_id: priceSetId, rules: priceRules = {}, ...moneyAmountData } = price;
-                const [moneyAmount] = await this.moneyAmountService_.create([moneyAmountData], sharedContext);
-                const [priceSetMoneyAmount] = await this.priceSetMoneyAmountService_.create([
-                    {
-                        price_set: priceSetId,
-                        price_list: priceList,
-                        money_amount: moneyAmount,
-                        title: "test",
-                        rules_count: Object.keys(priceRules).length,
-                    },
-                ], sharedContext);
-                await this.createPriceRules(Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
+            const pricesData = prices.map((price) => {
+                const priceRules = Object.entries(price.rules ?? {}).map(([ruleAttribute, ruleValue]) => {
                     return {
-                        price_set_id: priceSetId,
-                        rule_type: ruleTypeMap.get(ruleAttribute)?.id ||
-                            ruleTypeMap.get(ruleAttribute),
+                        price_set_id: price.price_set_id,
+                        rule_type_id: ruleTypeMap.get(ruleAttribute)?.id,
                         value: ruleValue,
-                        price_set_money_amount: priceSetMoneyAmount,
                     };
-                }), sharedContext);
-            }
-        }
-        return priceLists;
+                });
+                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,
+            };
+        });
+        return await this.priceListService_.create(priceListsToCreate, sharedContext);
     }
     async updatePriceLists(data, sharedContext = {}) {
         const priceLists = await this.updatePriceLists_(data, sharedContext);
-        return await this.baseRepository_.serialize(priceLists, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(priceLists, { populate: true });
     }
     async updatePriceLists_(data, sharedContext = {}) {
         const updatedPriceLists = [];
@@ -491,12 +392,12 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 }
                 const [priceListRule] = await this.priceListRuleService_.create([
                     {
-                        price_list: updatedPriceList,
-                        rule_type: ruleType?.id || ruleType,
+                        price_list_id: updatedPriceList.id,
+                        rule_type_id: ruleType?.id,
                     },
                 ], sharedContext);
                 for (const ruleValue of ruleValues) {
-                    await this.priceListRuleValueService_.create([{ price_list_rule: priceListRule, value: ruleValue }], sharedContext);
+                    await this.priceListRuleValueService_.create([{ price_list_rule_id: priceListRule.id, value: ruleValue }], sharedContext);
                 }
             }
         }
@@ -523,25 +424,19 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     async updatePriceListPrices_(data, sharedContext = {}) {
         const ruleTypeAttributes = [];
         const priceListIds = [];
-        const moneyAmountIds = [];
+        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) {
-                moneyAmountIds.push(price.id);
+                priceIds.push(price.id);
                 ruleTypeAttributes.push(...Object.keys(price.rules || {}));
             }
         }
-        const moneyAmounts = await this.listMoneyAmounts({ id: moneyAmountIds }, {
-            take: null,
-            relations: [
-                "price_set_money_amount",
-                "price_set_money_amount.price_rules",
-            ],
-        }, sharedContext);
-        const moneyAmountMap = new Map(moneyAmounts.map((ma) => [ma.id, ma]));
+        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);
@@ -573,36 +468,32 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             if (!priceList) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
-            const moneyAmountsToUpdate = [];
-            const priceRulesToDelete = [];
+            const priceRuleIdsToDelete = [];
             const priceRulesToCreate = [];
-            const psmaToUpdate = [];
-            for (const price of prices) {
-                const { rules, price_set_id, ...priceData } = price;
-                const moneyAmount = moneyAmountMap.get(price.id);
-                const priceSetMoneyAmount = moneyAmount.price_set_money_amount;
-                const priceRules = priceSetMoneyAmount.price_rules;
-                moneyAmountsToUpdate.push(priceData);
+            const pricesToUpdate = [];
+            for (const priceData of prices) {
+                const { rules, price_set_id, ...rest } = priceData;
+                const price = priceMap.get(rest.id);
+                const priceRules = price.price_rules;
                 if (typeof rules === "undefined") {
                     continue;
                 }
-                psmaToUpdate.push({
-                    id: priceSetMoneyAmount.id,
+                pricesToUpdate.push({
+                    ...rest,
                     rules_count: Object.keys(rules).length,
                 });
-                priceRulesToDelete.push(...priceRules.map((pr) => pr.id));
+                priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id));
                 priceRulesToCreate.push(...Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({
-                    price_set_id: price.price_set_id,
+                    price_set_id,
                     rule_type_id: ruleTypeMap.get(ruleAttribute).id,
                     value: ruleValue,
-                    price_set_money_amount_id: priceSetMoneyAmount.id,
+                    price_id: price.id,
                 })));
             }
             await Promise.all([
-                this.moneyAmountService_.update(moneyAmountsToUpdate),
-                this.priceRuleService_.delete(priceRulesToDelete),
+                this.priceRuleService_.delete(priceRuleIdsToDelete),
                 this.priceRuleService_.create(priceRulesToCreate),
-                this.priceSetMoneyAmountService_.update(psmaToUpdate),
+                this.priceService_.update(pricesToUpdate),
             ]);
         }
         return priceLists;
@@ -611,7 +502,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         await this.removePrices_(ids, sharedContext);
     }
     async removePrices_(ids, sharedContext = {}) {
-        await this.priceSetMoneyAmountService_.delete(ids, sharedContext);
+        await this.priceService_.delete(ids, sharedContext);
     }
     async addPriceListPrices(data, sharedContext = {}) {
         return await this.addPriceListPrices_(data, sharedContext);
@@ -658,29 +549,27 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             if (!priceList) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
-            await Promise.all(prices.map(async (price) => {
-                const priceRules = price.rules || {};
+            await Promise.all(prices.map(async (priceData) => {
+                const priceRules = priceData.rules || {};
                 const noOfRules = Object.keys(priceRules).length;
-                const [moneyAmount] = await this.moneyAmountService_.create([price], sharedContext);
-                const [psma] = await this.priceSetMoneyAmountService_.create([
+                const [price] = await this.priceService_.create([
                     {
-                        price_set: price.price_set_id,
-                        money_amount: moneyAmount.id,
+                        ...priceData,
+                        price_set_id: priceData.price_set_id,
                         title: "test",
-                        price_list: priceList.id,
+                        price_list_id: priceList.id,
                         rules_count: noOfRules,
                     },
                 ], sharedContext);
-                await this.createPriceRules(Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
+                await this.priceRuleService_.create(Object.entries(priceRules).map(([ruleAttribute, ruleValue]) => {
                     return {
-                        price_set_id: price.price_set_id,
-                        rule_type: ruleTypeMap.get(ruleAttribute)?.id ||
-                            ruleTypeMap.get(ruleAttribute),
+                        price_set_id: priceData.price_set_id,
+                        rule_type_id: ruleTypeMap.get(ruleAttribute)?.id,
                         value: ruleValue,
-                        price_set_money_amount: psma,
+                        price_id: price.id,
                     };
                 }), sharedContext);
-                return psma;
+                return price;
             }));
         }
         return priceLists;
@@ -690,15 +579,9 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         return priceList;
     }
     async setPriceListRules_(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 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 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 = [];
@@ -708,9 +591,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             if (!priceList) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
-            const priceListRulesMap = new Map(priceList.price_list_rules
-                .getItems()
-                .map((p) => [p.rule_type.rule_attribute, p]));
+            const priceListRulesMap = new Map(priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p]));
             const priceListRuleValues = new Map();
             await Promise.all(Object.entries(rules).map(async ([key, value]) => {
                 const ruleType = ruleTypeMap.get(key);
@@ -721,8 +602,8 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                 priceListRuleValues.set(ruleType.id, Array.isArray(value) ? value : [value]);
                 if (!rule) {
                     rulesToCreate.push({
-                        rule_type: ruleType.id,
-                        price_list: priceListId,
+                        rule_type_id: ruleType.id,
+                        price_list_id: priceListId,
                     });
                 }
                 else {
@@ -733,23 +614,21 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
         const [createdRules, priceListValuesToDelete] = await Promise.all([
             this.priceListRuleService_.create(rulesToCreate),
-            this.priceListRuleValueService_.list({
-                price_list_rule_id: ruleIdsToUpdate,
-            }, { take: null }),
+            this.priceListRuleValueService_.list({ price_list_rule_id: ruleIdsToUpdate }, { take: null }),
         ]);
         const priceListRuleValuesToCreate = [];
-        for (const { id, price_list, rule_type } of createdRules) {
-            const ruleValues = priceRuleValues.get(price_list.id ?? price_list);
+        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 ?? rule_type);
+            const values = ruleValues.get(rule_type_id);
             if (!values) {
                 continue;
             }
             values.forEach((v) => {
                 priceListRuleValuesToCreate.push({
-                    price_list_rule: id,
+                    price_list_rule_id: id,
                     value: v,
                 });
             });
@@ -758,18 +637,14 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             this.priceListRuleValueService_.delete(priceListValuesToDelete.map((p) => p.id), sharedContext),
             this.priceListRuleValueService_.create(priceListRuleValuesToCreate, sharedContext),
         ]);
-        return await this.baseRepository_.serialize(priceLists, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(priceLists, { populate: true });
     }
     async removePriceListRules(data, sharedContext = {}) {
         const [priceList] = await this.removePriceListRules_([data], sharedContext);
         return priceList;
     }
     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 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) {
@@ -777,9 +652,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             if (!priceList) {
                 throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Price list with id: ${priceListId} not found`);
             }
-            const priceListRulesMap = new Map(priceList.price_list_rules
-                .getItems()
-                .map((p) => [p.rule_type.rule_attribute, p]));
+            const priceListRulesMap = new Map(priceList.price_list_rules.map((p) => [p.rule_type.rule_attribute, p]));
             await Promise.all(rules.map(async (rule_attribute) => {
                 const rule = priceListRulesMap.get(rule_attribute);
                 if (rule) {
@@ -788,9 +661,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             }));
         }
         await this.priceListRuleService_.delete(idsToDelete);
-        return await this.baseRepository_.serialize(priceLists, {
-            populate: true,
-        });
+        return await this.baseRepository_.serialize(priceLists, { populate: true });
     }
 }
 exports.default = PricingModuleService;
@@ -857,62 +728,6 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], 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, "createMoneyAmounts", 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, "updateMoneyAmounts", 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, "createRuleTypes", 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, "updateRuleTypes", 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, "createPriceSetMoneyAmountRules", 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, "updatePriceSetMoneyAmountRules", 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, "createPriceRules", 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, "updatePriceRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),