@medusajs/pricing 0.1.12-snapshot-20240328221015 → 0.2.0-next-20240429170320

package/dist/joiner-config.d.ts

@@ -4,6 +4,7 @@ export declare const LinkableKeys: {
     price_set_id: string;
     price_list_id: string;
     price_id: string;
+    rule_type_id: string;
 };
 export declare const entityNameToLinkableKeysMap: MapToConfig;
 export declare const joinerConfig: ModuleJoinerConfig;

package/dist/joiner-config.js

@@ -11,6 +11,7 @@ exports.LinkableKeys = {
     price_set_id: _models_1.PriceSet.name,
     price_list_id: _models_1.PriceList.name,
     price_id: _models_1.Price.name,
+    rule_type_id: _models_1.RuleType.name,
 };
 const entityLinkableKeysMap = {};
 Object.entries(exports.LinkableKeys).forEach(([key, value]) => {
@@ -39,5 +40,17 @@ exports.joinerConfig = {
                 methodSuffix: "PriceLists",
             },
         },
+        {
+            name: ["price", "prices"],
+            args: {
+                methodSuffix: "Prices",
+            },
+        },
+        {
+            name: ["rule_type", "rule_types"],
+            args: {
+                methodSuffix: "RuleTypes",
+            },
+        },
     ],
 };

package/dist/migrations/Migration20230929122253.js

@@ -6,7 +6,7 @@ class Migration20230929122253 extends migrations_1.Migration {
     async up() {
         this.addSql('create table if not exists "money_amount" ("id" text not null, "currency_code" text not null, "amount" numeric not null, "min_quantity" numeric null, "max_quantity" numeric null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "money_amount_pkey" primary key ("id"));');
         this.addSql('create table "price_set" ("id" text not null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "price_set_pkey" primary key ("id"));');
-        this.addSql('create table "price" ("id" text not null, "title" text, "price_set_id" text not null, "money_amount_id" text not null, "rules_count" integer not null default 0, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "price_pkey" primary key ("id"));');
+        this.addSql('create table "price" ("id" text not null, "title" text, "price_set_id" text not null, "money_amount_id" text not null, "raw_amount" jsonb not null, "rules_count" integer not null default 0, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "price_pkey" primary key ("id"));');
         this.addSql('alter table "price" add constraint "price_money_amount_id_unique" unique ("money_amount_id");');
         this.addSql('create table "rule_type" ("id" text not null, "name" text not null, "rule_attribute" text not null, "default_priority" integer not null default 0, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "rule_type_pkey" primary key ("id"));');
         this.addSql('create table "price_set_rule_type" ("id" text not null, "price_set_id" text not null, "rule_type_id" text not null, "created_at" timestamptz not null default now(), "updated_at" timestamptz not null default now(), "deleted_at" timestamptz null, constraint "price_set_rule_type_pkey" primary key ("id"));');

package/dist/models/price-list.js

@@ -47,10 +47,12 @@ __decorate([
     __metadata("design:type", String)
 ], PriceList.prototype, "id", void 0);
 __decorate([
+    (0, utils_1.Searchable)(),
     (0, core_1.Property)({ columnType: "text" }),
     __metadata("design:type", String)
 ], PriceList.prototype, "title", void 0);
 __decorate([
+    (0, utils_1.Searchable)(),
     (0, core_1.Property)({ columnType: "text" }),
     __metadata("design:type", String)
 ], PriceList.prototype, "description", void 0);

package/dist/models/price.d.ts

@@ -1,4 +1,5 @@
 import { DAL } from "@medusajs/types";
+import { BigNumber } from "@medusajs/utils";
 import { Collection, OptionalProps } from "@mikro-orm/core";
 import PriceList from "./price-list";
 import PriceRule from "./price-rule";
@@ -9,7 +10,8 @@ export default class Price {
     id: string;
     title: string | null;
     currency_code: string;
-    amount: number;
+    amount: BigNumber | number;
+    raw_amount: Record<string, unknown>;
     min_quantity: number | null;
     max_quantity: number | null;
     price_set_id: string;

package/dist/models/price.js

@@ -74,9 +74,13 @@ __decorate([
     __metadata("design:type", String)
 ], Price.prototype, "currency_code", void 0);
 __decorate([
-    (0, core_1.Property)({ columnType: "numeric", serializer: Number }),
-    __metadata("design:type", Number)
+    (0, utils_1.MikroOrmBigNumberProperty)(),
+    __metadata("design:type", Object)
 ], Price.prototype, "amount", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "jsonb" }),
+    __metadata("design:type", Object)
+], Price.prototype, "raw_amount", void 0);
 __decorate([
     (0, core_1.Property)({ columnType: "numeric", nullable: true }),
     __metadata("design:type", Object)

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

@@ -1,7 +1,8 @@
-import { AddPricesDTO, Context, DAL, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RuleTypeDTO } from "@medusajs/types";
+import { AddPricesDTO, Context, CreatePriceRuleDTO, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, ModulesSdkTypes, PriceSetDTO, PricingContext, PricingFilters, PricingRepositoryService, PricingTypes, RuleTypeDTO, UpsertPriceSetDTO } from "@medusajs/types";
 import { ModulesSdkUtils } from "@medusajs/utils";
 import { Price, PriceList, PriceListRule, PriceListRuleValue, PriceRule, PriceSet, PriceSetRuleType, RuleType } from "../models";
 import { PriceListService, RuleTypeService } from ".";
+import { UpdatePriceSetInput } from "src/types/services";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     pricingRepository: PricingRepositoryService;
@@ -49,23 +50,31 @@ export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet,
     protected readonly priceListRuleValueService_: ModulesSdkTypes.InternalModuleService<TPriceListRuleValue>;
     constructor({ baseRepository, pricingRepository, ruleTypeService, priceSetService, priceRuleService, priceSetRuleTypeService, priceService, priceListService, priceListRuleService, priceListRuleValueService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
+    private setupCalculatedPriceConfig_;
+    list(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PriceSetDTO[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PriceSetDTO[], number]>;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSet[]>;
     create(data: PricingTypes.CreatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
     create(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
+    upsert(data: UpsertPriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
+    upsert(data: UpsertPriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
+    update(id: string, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO>;
+    update(selector: PricingTypes.FilterablePriceSetProps, data: PricingTypes.UpdatePriceSetDTO, sharedContext?: Context): Promise<PriceSetDTO[]>;
+    private normalizeUpdateData;
+    protected update_(data: UpdatePriceSetInput[], sharedContext?: Context): Promise<PriceSet[]>;
     addRules(data: PricingTypes.AddRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
     addRules(data: PricingTypes.AddRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
     addPrices(data: AddPricesDTO, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
     addPrices(data: AddPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
     removeRules(data: PricingTypes.RemovePriceSetRulesDTO[], sharedContext?: Context): Promise<void>;
-    update(data: PricingTypes.UpdatePriceSetDTO[], sharedContext?: Context): Promise<PriceSetDTO[]>;
     createPriceLists(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     updatePriceLists(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
     createPriceListRules(data: PricingTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;
     createPriceListRules_(data: PricingTypes.CreatePriceListRuleDTO[], sharedContext?: Context): Promise<TPriceListRule[]>;
     updatePriceListRules(data: PricingTypes.UpdatePriceListRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListRuleDTO[]>;
-    updatePriceListPrices(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    updatePriceListPrices(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
     removePrices(ids: string[], sharedContext?: Context): Promise<void>;
-    addPriceListPrices(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    addPriceListPrices(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceDTO[]>;
     setPriceListRules(data: PricingTypes.SetPriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
     removePriceListRules(data: PricingTypes.RemovePriceListRulesDTO, sharedContext?: Context): Promise<PricingTypes.PriceListDTO>;
     protected create_(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<TPriceSet[]>;
@@ -73,9 +82,9 @@ export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet,
     protected addPrices_(input: AddPricesDTO[], sharedContext?: Context): Promise<void>;
     protected createPriceLists_(data: PricingTypes.CreatePriceListDTO[], sharedContext?: Context): Promise<TPriceList[]>;
     protected updatePriceLists_(data: PricingTypes.UpdatePriceListDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
-    protected updatePriceListPrices_(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    protected updatePriceListPrices_(data: PricingTypes.UpdatePriceListPricesDTO[], sharedContext?: Context): Promise<TPrice[]>;
     protected removePrices_(ids: string[], sharedContext?: Context): Promise<void>;
-    protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceListDTO[]>;
+    protected addPriceListPrices_(data: PricingTypes.AddPriceListPricesDTO[], sharedContext?: Context): Promise<TPrice[]>;
     protected setPriceListRules_(data: PricingTypes.SetPriceListRulesDTO[], sharedContext?: Context): Promise<TPriceList[]>;
     protected removePriceListRules_(data: PricingTypes.RemovePriceListRulesDTO[], sharedContext?: Context): Promise<TPriceList[]>;
 }

package/dist/services/pricing-module.js

@@ -17,8 +17,8 @@ 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 price_set_1 = require("../models/price-set");
 const generateMethodForModels = [
     _models_1.PriceList,
     _models_1.PriceListRule,
@@ -48,13 +48,61 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
+    setupCalculatedPriceConfig_(filters, config) {
+        const fieldIdx = config.relations?.indexOf("calculated_price");
+        const shouldCalculatePrice = fieldIdx > -1;
+        if (!shouldCalculatePrice) {
+            return;
+        }
+        let pricingContext = filters.context ?? {};
+        // cleanup virtual field "calculated_price"
+        config.relations?.splice(fieldIdx, 1);
+        delete filters.context;
+        return pricingContext;
+    }
+    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;
+    }
+    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 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
-            // inject custom price selection here
+            // 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);
@@ -94,12 +142,103 @@ 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);
+        // TODO: Remove the need to refetch the data here
         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];
+        return await this.baseRepository_.serialize(Array.isArray(data) ? results : results[0]);
+    }
+    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.create_(forCreate, sharedContext));
+        }
+        if (forUpdate.length) {
+            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 update(idOrSelector, data, sharedContext = {}) {
+        let normalizedInput = [];
+        if ((0, utils_1.isString)(idOrSelector)) {
+            // Check if the ID exists, it will throw if not.
+            await this.priceSetService_.retrieve(idOrSelector, {}, sharedContext);
+            normalizedInput = [{ id: idOrSelector, ...data }];
+        }
+        else {
+            const priceSets = await this.priceSetService_.list(idOrSelector, {}, sharedContext);
+            normalizedInput = priceSets.map((priceSet) => ({
+                id: priceSet.id,
+                ...data,
+            }));
+        }
+        const updateResult = await this.update_(normalizedInput, sharedContext);
+        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());
+        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, sharedContext);
+        const prices = normalizedData.flatMap((priceSet) => priceSet.prices || []);
+        const upsertedPrices = await this.priceService_.upsertWithReplace(prices, {
+            relations: ["price_rules"],
+        }, sharedContext);
+        const priceSetsToUpsert = normalizedData.map((priceSet) => {
+            const { prices, ...rest } = priceSet;
+            return {
+                ...rest,
+                prices: upsertedPrices
+                    .filter((p) => p.price_set_id === priceSet.id)
+                    .map((price) => {
+                    // @ts-ignore
+                    delete price.price_rules;
+                    return price;
+                }),
+            };
+        });
+        return await this.priceSetService_.upsertWithReplace(priceSetsToUpsert, { relations: ["prices"] }, sharedContext);
     }
     async addRules(data, sharedContext = {}) {
         const inputs = Array.isArray(data) ? data : [data];
@@ -131,10 +270,6 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         await this.priceSetRuleTypeService_.delete(priceSetRuleTypes.map((psrt) => psrt.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);
-    }
     async createPriceLists(data, sharedContext = {}) {
         const priceLists = await this.createPriceLists_(data, sharedContext);
         return await this.baseRepository_.serialize(priceLists);
@@ -159,13 +294,15 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         });
     }
     async updatePriceListPrices(data, sharedContext = {}) {
-        return await this.updatePriceListPrices_(data, sharedContext);
+        const prices = await this.updatePriceListPrices_(data, sharedContext);
+        return await this.baseRepository_.serialize(prices);
     }
     async removePrices(ids, sharedContext = {}) {
         await this.removePrices_(ids, sharedContext);
     }
     async addPriceListPrices(data, sharedContext = {}) {
-        return await this.addPriceListPrices_(data, sharedContext);
+        const prices = await this.addPriceListPrices_(data, sharedContext);
+        return await this.baseRepository_.serialize(prices);
     }
     async setPriceListRules(data, sharedContext = {}) {
         const [priceList] = await this.setPriceListRules_([data], sharedContext);
@@ -229,7 +366,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
                     });
                     return {
                         ...rest,
-                        title: "test",
+                        title: "",
                         rules_count: numberOfRules,
                         price_rules: Array.from(rulesDataMap.values()),
                     };
@@ -475,40 +612,37 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
         }
         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`);
             }
-            const priceRuleIdsToDelete = [];
-            const priceRulesToCreate = [];
-            const pricesToUpdate = [];
             for (const priceData of prices) {
-                const { rules, price_set_id, ...rest } = priceData;
+                const { rules = {}, price_set_id, ...rest } = priceData;
                 const price = priceMap.get(rest.id);
                 const priceRules = price.price_rules;
-                if (!(0, utils_1.isDefined)(rules)) {
-                    continue;
-                }
+                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,
-                    price_rules: Object.entries(rules).map(([ruleAttribute, ruleValue]) => ({
-                        price_set_id,
-                        rule_type_id: ruleTypeMap.get(ruleAttribute).id,
-                        value: ruleValue,
-                        price_id: price.id,
-                    })),
                 });
                 priceRuleIdsToDelete.push(...priceRules.map((pr) => pr.id));
             }
-            await (0, utils_1.promiseAll)([
-                this.priceRuleService_.delete(priceRuleIdsToDelete),
-                this.priceRuleService_.create(priceRulesToCreate),
-                this.priceService_.update(pricesToUpdate),
-            ]);
         }
-        return priceLists;
+        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);
@@ -577,8 +711,7 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
             });
             pricesToCreate.push(...priceListPricesToCreate);
         }
-        await this.priceService_.create(pricesToCreate, sharedContext);
-        return priceLists;
+        return await this.priceService_.create(pricesToCreate, sharedContext);
     }
     async setPriceListRules_(data, sharedContext = {}) {
         // TODO: re think this method
@@ -664,6 +797,20 @@ class PricingModuleService extends utils_1.ModulesSdkUtils.abstractModuleService
     }
 }
 exports.default = PricingModuleService;
+__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, "list", 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, "listAndCount", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -684,28 +831,42 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "addRules", null);
+], PricingModuleService.prototype, "upsert", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
+    __param(2, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], PricingModuleService.prototype, "addPrices", 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, "removeRules", 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_"),
+    __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, "update", null);
+], PricingModuleService.prototype, "removeRules", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),

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

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

package/dist/types/services/index.js

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

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

@@ -0,0 +1,4 @@
+import { UpdatePriceSetDTO } from "@medusajs/types";
+export interface UpdatePriceSetInput extends UpdatePriceSetDTO {
+    id: string;
+}

package/dist/types/services/price-set.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/pricing",
-  "version": "0.1.12-snapshot-20240328221015",
+  "version": "0.2.0-next-20240429170320",
   "description": "Medusa Pricing module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -40,7 +40,7 @@
     "@mikro-orm/cli": "5.9.7",
     "cross-env": "^5.2.1",
     "jest": "^29.6.3",
-    "medusa-test-utils": "1.1.44-snapshot-20240328221015",
+    "medusa-test-utils": "1.1.44-next-20240429170320",
     "rimraf": "^3.0.2",
     "ts-jest": "^29.1.1",
     "ts-node": "^10.9.1",
@@ -48,9 +48,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.12.10",
-    "@medusajs/types": "1.12.0-snapshot-20240328221015",
-    "@medusajs/utils": "1.12.0-snapshot-20240328221015",
+    "@medusajs/modules-sdk": "1.12.11-next-20240429170320",
+    "@medusajs/types": "1.12.0-next-20240429170320",
+    "@medusajs/utils": "1.12.0-next-20240429170320",
     "@mikro-orm/core": "5.9.7",
     "@mikro-orm/migrations": "5.9.7",
     "@mikro-orm/postgresql": "5.9.7",