@medusajs/pricing 0.0.2 → 0.0.3-next-20230912130318

package/dist/joiner-config.d.ts

@@ -2,7 +2,8 @@ import { ModuleJoinerConfig } from "@medusajs/types";
 import { MapToConfig } from "@medusajs/utils";
 export declare enum LinkableKeys {
     MONEY_AMOUNT_ID = "money_amount_id",
-    CURRENCY_CODE = "currency_code"
+    CURRENCY_CODE = "currency_code",
+    PRICE_SET_ID = "price_set_id"
 }
 export declare const entityNameToLinkableKeysMap: MapToConfig;
 export declare const joinerConfig: ModuleJoinerConfig;

package/dist/joiner-config.js

@@ -1,16 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.joinerConfig = exports.entityNameToLinkableKeysMap = exports.LinkableKeys = void 0;
 const modules_sdk_1 = require("@medusajs/modules-sdk");
-const _models_1 = require("./models");
+const Models = __importStar(require("./models"));
 var LinkableKeys;
 (function (LinkableKeys) {
     LinkableKeys["MONEY_AMOUNT_ID"] = "money_amount_id";
     LinkableKeys["CURRENCY_CODE"] = "currency_code";
+    LinkableKeys["PRICE_SET_ID"] = "price_set_id";
 })(LinkableKeys || (exports.LinkableKeys = LinkableKeys = {}));
 exports.entityNameToLinkableKeysMap = {
-    [_models_1.Currency.name]: [{ mapTo: LinkableKeys.CURRENCY_CODE, valueFrom: "code" }],
-    [_models_1.MoneyAmount.name]: [
+    [Models.PriceSet.name]: [
+        { mapTo: LinkableKeys.PRICE_SET_ID, valueFrom: "id" },
+    ],
+    [Models.Currency.name]: [
+        { mapTo: LinkableKeys.CURRENCY_CODE, valueFrom: "code" },
+    ],
+    [Models.MoneyAmount.name]: [
         { mapTo: LinkableKeys.MONEY_AMOUNT_ID, valueFrom: "id" },
     ],
 };
@@ -19,11 +48,23 @@ exports.joinerConfig = {
     primaryKeys: ["id", "currency_code"],
     linkableKeys: Object.values(LinkableKeys),
     alias: [
+        {
+            name: "price_set",
+        },
+        {
+            name: "price_sets",
+        },
         {
             name: "money_amount",
+            args: {
+                methodSuffix: "MoneyAmounts",
+            },
         },
         {
             name: "money_amounts",
+            args: {
+                methodSuffix: "MoneyAmounts",
+            },
         },
         {
             name: "currency",

package/dist/loaders/container.js

@@ -24,15 +24,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const defaultRepositories = __importStar(require("../repositories"));
-const _repositories_1 = require("../repositories");
-const _services_1 = require("../services");
+const defaultServices = __importStar(require("../services"));
 const utils_1 = require("@medusajs/utils");
 const awilix_1 = require("awilix");
 exports.default = async ({ container, options, }) => {
     const customRepositories = options?.repositories;
     container.register({
-        currencyService: (0, awilix_1.asClass)(_services_1.CurrencyService).singleton(),
-        moneyAmountService: (0, awilix_1.asClass)(_services_1.MoneyAmountService).singleton(),
+        currencyService: (0, awilix_1.asClass)(defaultServices.CurrencyService).singleton(),
+        moneyAmountService: (0, awilix_1.asClass)(defaultServices.MoneyAmountService).singleton(),
+        priceSetService: (0, awilix_1.asClass)(defaultServices.PriceSetService).singleton(),
     });
     if (customRepositories) {
         (0, utils_1.loadCustomRepositories)({
@@ -47,8 +47,9 @@ exports.default = async ({ container, options, }) => {
 };
 function loadDefaultRepositories({ container }) {
     container.register({
-        baseRepository: (0, awilix_1.asClass)(_repositories_1.BaseRepository).singleton(),
-        currencyRepository: (0, awilix_1.asClass)(_repositories_1.CurrencyRepository).singleton(),
-        moneyAmountRepository: (0, awilix_1.asClass)(_repositories_1.MoneyAmountRepository).singleton(),
+        baseRepository: (0, awilix_1.asClass)(defaultRepositories.BaseRepository).singleton(),
+        currencyRepository: (0, awilix_1.asClass)(defaultRepositories.CurrencyRepository).singleton(),
+        moneyAmountRepository: (0, awilix_1.asClass)(defaultRepositories.MoneyAmountRepository).singleton(),
+        priceSetRepository: (0, awilix_1.asClass)(defaultRepositories.PriceSetRepository).singleton(),
     });
 }

package/dist/migrations/Migration20230907144224.d.ts

@@ -0,0 +1,4 @@
+import { Migration } from "@mikro-orm/migrations";
+export declare class Migration20230907144224 extends Migration {
+    up(): Promise<void>;
+}

package/dist/migrations/Migration20230907144224.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migration20230907144224 = void 0;
+const migrations_1 = require("@mikro-orm/migrations");
+class Migration20230907144224 extends migrations_1.Migration {
+    async up() {
+        this.addSql('create table "currency" ("code" text not null, "symbol" text not null, "symbol_native" text not null, "name" text not null, constraint "currency_pkey" primary key ("code"));');
+        this.addSql('create table "money_amount" ("id" text not null, "currency_code" text null, "amount" numeric null, "min_quantity" numeric null, "max_quantity" numeric null, constraint "money_amount_pkey" primary key ("id"));');
+        this.addSql('create index "IDX_money_amount_currency_code" on "money_amount" ("currency_code");');
+        this.addSql('create table "price_set" ("id" text not null, constraint "price_set_pkey" primary key ("id"));');
+        this.addSql('create table "price_set_money_amount" ("id" text not null, "price_set_id" text null, "money_amount_id" text null, "title" text not null, constraint "price_set_money_amount_pkey" primary key ("id", "price_set_id", "money_amount_id"));');
+        this.addSql('alter table "money_amount" add constraint "money_amount_currency_code_foreign" foreign key ("currency_code") references "currency" ("code") on update cascade on delete set null;');
+        this.addSql('alter table "price_set_money_amount" add constraint "price_set_money_amount_price_set_id_foreign" foreign key ("price_set_id") references "price_set" ("id") on update cascade;');
+        this.addSql('alter table "price_set_money_amount" add constraint "price_set_money_amount_money_amount_id_foreign" foreign key ("money_amount_id") references "money_amount" ("id") on update cascade;');
+    }
+}
+exports.Migration20230907144224 = Migration20230907144224;

package/dist/models/index.d.ts

@@ -1,2 +1,4 @@
 export { default as Currency } from "./currency";
 export { default as MoneyAmount } from "./money-amount";
+export { default as PriceSet } from "./price-set";
+export { default as PriceSetMoneyAmount } from "./price-set-money-amount";

package/dist/models/index.js

@@ -3,8 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoneyAmount = exports.Currency = void 0;
+exports.PriceSetMoneyAmount = exports.PriceSet = exports.MoneyAmount = exports.Currency = void 0;
 var currency_1 = require("./currency");
 Object.defineProperty(exports, "Currency", { enumerable: true, get: function () { return __importDefault(currency_1).default; } });
 var money_amount_1 = require("./money-amount");
 Object.defineProperty(exports, "MoneyAmount", { enumerable: true, get: function () { return __importDefault(money_amount_1).default; } });
+var price_set_1 = require("./price-set");
+Object.defineProperty(exports, "PriceSet", { enumerable: true, get: function () { return __importDefault(price_set_1).default; } });
+var price_set_money_amount_1 = require("./price-set-money-amount");
+Object.defineProperty(exports, "PriceSetMoneyAmount", { enumerable: true, get: function () { return __importDefault(price_set_money_amount_1).default; } });

package/dist/models/money-amount.d.ts

@@ -1,7 +1,10 @@
+import { Collection } from "@mikro-orm/core";
 import Currency from "./currency";
+import PriceSet from "./price-set";
 declare class MoneyAmount {
     id: string;
     currency_code?: string;
+    price_sets: Collection<PriceSet, object>;
     currency?: Currency;
     amount?: number;
     min_quantity?: number | null;

package/dist/models/money-amount.js

@@ -15,7 +15,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@medusajs/utils");
 const core_1 = require("@mikro-orm/core");
 const currency_1 = __importDefault(require("./currency"));
+const price_set_1 = __importDefault(require("./price-set"));
 let MoneyAmount = class MoneyAmount {
+    constructor() {
+        this.price_sets = new core_1.Collection(this);
+    }
     onCreate() {
         this.id = (0, utils_1.generateEntityId)(this.id, "ma");
     }
@@ -28,6 +32,13 @@ __decorate([
     (0, core_1.Property)({ columnType: "text", nullable: true }),
     __metadata("design:type", String)
 ], MoneyAmount.prototype, "currency_code", void 0);
+__decorate([
+    (0, core_1.ManyToMany)({
+        entity: () => price_set_1.default,
+        mappedBy: (ps) => ps.money_amounts,
+    }),
+    __metadata("design:type", Object)
+], MoneyAmount.prototype, "price_sets", void 0);
 __decorate([
     (0, core_1.ManyToOne)(() => currency_1.default, {
         nullable: true,

package/dist/models/price-set-money-amount.d.ts

@@ -0,0 +1,12 @@
+import { PrimaryKeyType } from "@mikro-orm/core";
+import MoneyAmount from "./money-amount";
+import PriceSet from "./price-set";
+export default class PriceSetMoneyAmount {
+    id: string;
+    title: string;
+    price_set?: PriceSet;
+    money_amount?: MoneyAmount;
+    onCreate(): void;
+    [PrimaryKeyType]?: [string, string];
+    constructor(money_amount: MoneyAmount, price_set: PriceSet);
+}

package/dist/models/price-set-money-amount.js

@@ -0,0 +1,54 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const money_amount_1 = __importDefault(require("./money-amount"));
+const price_set_1 = __importDefault(require("./price-set"));
+let PriceSetMoneyAmount = class PriceSetMoneyAmount {
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "psma");
+    }
+    constructor(money_amount, price_set) {
+        this.money_amount = money_amount;
+        this.price_set = price_set;
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], PriceSetMoneyAmount.prototype, "id", void 0);
+__decorate([
+    (0, core_1.Property)({ columnType: "text" }),
+    __metadata("design:type", String)
+], PriceSetMoneyAmount.prototype, "title", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => price_set_1.default, { onDelete: "cascade" }),
+    __metadata("design:type", price_set_1.default)
+], PriceSetMoneyAmount.prototype, "price_set", void 0);
+__decorate([
+    (0, core_1.ManyToOne)(() => money_amount_1.default, {}),
+    __metadata("design:type", money_amount_1.default)
+], PriceSetMoneyAmount.prototype, "money_amount", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PriceSetMoneyAmount.prototype, "onCreate", null);
+PriceSetMoneyAmount = __decorate([
+    (0, core_1.Entity)(),
+    __metadata("design:paramtypes", [money_amount_1.default, price_set_1.default])
+], PriceSetMoneyAmount);
+exports.default = PriceSetMoneyAmount;

package/dist/models/price-set.d.ts

@@ -0,0 +1,7 @@
+import { Collection } from "@mikro-orm/core";
+import MoneyAmount from "./money-amount";
+export default class PriceSet {
+    id: string;
+    money_amounts: Collection<MoneyAmount, object>;
+    onCreate(): void;
+}

package/dist/models/price-set.js

@@ -0,0 +1,47 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const money_amount_1 = __importDefault(require("./money-amount"));
+const price_set_money_amount_1 = __importDefault(require("./price-set-money-amount"));
+let PriceSet = class PriceSet {
+    constructor() {
+        this.money_amounts = new core_1.Collection(this);
+    }
+    onCreate() {
+        this.id = (0, utils_1.generateEntityId)(this.id, "pset");
+    }
+};
+__decorate([
+    (0, core_1.PrimaryKey)({ columnType: "text" }),
+    __metadata("design:type", String)
+], PriceSet.prototype, "id", void 0);
+__decorate([
+    (0, core_1.ManyToMany)({
+        entity: () => money_amount_1.default,
+        pivotEntity: () => price_set_money_amount_1.default,
+    }),
+    __metadata("design:type", Object)
+], PriceSet.prototype, "money_amounts", void 0);
+__decorate([
+    (0, core_1.BeforeCreate)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], PriceSet.prototype, "onCreate", null);
+PriceSet = __decorate([
+    (0, core_1.Entity)()
+], PriceSet);
+exports.default = PriceSet;

package/dist/repositories/index.d.ts

@@ -1,3 +1,4 @@
 export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils";
 export { CurrencyRepository } from "./currency";
 export { MoneyAmountRepository } from "./money-amount";
+export { PriceSetRepository } from "./price-set";

package/dist/repositories/index.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoneyAmountRepository = exports.CurrencyRepository = exports.BaseRepository = void 0;
+exports.PriceSetRepository = exports.MoneyAmountRepository = exports.CurrencyRepository = exports.BaseRepository = void 0;
 var utils_1 = require("@medusajs/utils");
 Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return utils_1.MikroOrmBaseRepository; } });
 var currency_1 = require("./currency");
 Object.defineProperty(exports, "CurrencyRepository", { enumerable: true, get: function () { return currency_1.CurrencyRepository; } });
 var money_amount_1 = require("./money-amount");
 Object.defineProperty(exports, "MoneyAmountRepository", { enumerable: true, get: function () { return money_amount_1.MoneyAmountRepository; } });
+var price_set_1 = require("./price-set");
+Object.defineProperty(exports, "PriceSetRepository", { enumerable: true, get: function () { return price_set_1.PriceSetRepository; } });

package/dist/repositories/price-set.d.ts

@@ -0,0 +1,15 @@
+import { Context, CreatePriceSetDTO, DAL, UpdatePriceSetDTO } from "@medusajs/types";
+import { DALUtils } from "@medusajs/utils";
+import { SqlEntityManager } from "@mikro-orm/postgresql";
+import { PriceSet } from "../models";
+export declare class PriceSetRepository extends DALUtils.MikroOrmBaseRepository {
+    protected readonly manager_: SqlEntityManager;
+    constructor({ manager }: {
+        manager: SqlEntityManager;
+    });
+    find(findOptions?: DAL.FindOptions<PriceSet>, context?: Context): Promise<PriceSet[]>;
+    findAndCount(findOptions?: DAL.FindOptions<PriceSet>, context?: Context): Promise<[PriceSet[], number]>;
+    delete(ids: string[], context?: Context): Promise<void>;
+    create(data: CreatePriceSetDTO[], context?: Context): Promise<PriceSet[]>;
+    update(data: UpdatePriceSetDTO[], context?: Context): Promise<PriceSet[]>;
+}

package/dist/repositories/price-set.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriceSetRepository = void 0;
+const utils_1 = require("@medusajs/utils");
+const core_1 = require("@mikro-orm/core");
+const _models_1 = require("../models");
+class PriceSetRepository extends utils_1.DALUtils.MikroOrmBaseRepository {
+    constructor({ manager }) {
+        // @ts-ignore
+        // eslint-disable-next-line prefer-rest-params
+        super(...arguments);
+        this.manager_ = manager;
+    }
+    async find(findOptions = { where: {} }, context = {}) {
+        const manager = this.getActiveManager(context);
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return await manager.find(_models_1.PriceSet, findOptions_.where, findOptions_.options);
+    }
+    async findAndCount(findOptions = { where: {} }, context = {}) {
+        const manager = this.getActiveManager(context);
+        const findOptions_ = { ...findOptions };
+        findOptions_.options ?? (findOptions_.options = {});
+        Object.assign(findOptions_.options, {
+            strategy: core_1.LoadStrategy.SELECT_IN,
+        });
+        return await manager.findAndCount(_models_1.PriceSet, findOptions_.where, findOptions_.options);
+    }
+    async delete(ids, context = {}) {
+        const manager = this.getActiveManager(context);
+        await manager.nativeDelete(_models_1.PriceSet, { id: { $in: ids } }, {});
+    }
+    async create(data, context = {}) {
+        const manager = this.getActiveManager(context);
+        const priceSets = data.map((priceSetData) => {
+            return manager.create(_models_1.PriceSet, priceSetData);
+        });
+        manager.persist(priceSets);
+        return priceSets;
+    }
+    async update(data, context = {}) {
+        const manager = this.getActiveManager(context);
+        const priceSetIds = data.map((priceSetData) => priceSetData.id);
+        const existingPriceSets = await this.find({
+            where: {
+                id: {
+                    $in: priceSetIds,
+                },
+            },
+        }, context);
+        const existingPriceSetMap = new Map(existingPriceSets.map((priceSet) => [
+            priceSet.id,
+            priceSet,
+        ]));
+        const priceSets = data.map((priceSetData) => {
+            const existingPriceSet = existingPriceSetMap.get(priceSetData.id);
+            if (!existingPriceSet) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `PriceSet with id "${priceSetData.id}" not found`);
+            }
+            return manager.assign(existingPriceSet, priceSetData);
+        });
+        manager.persist(priceSets);
+        return priceSets;
+    }
+}
+exports.PriceSetRepository = PriceSetRepository;

package/dist/scripts/seed.js

@@ -31,8 +31,8 @@ const path_1 = require("path");
 async function run({ options, logger, path, }) {
     logger ?? (logger = console);
     logger.info(`Loading seed data from ${path}...`);
-    const { currenciesData, moneyAmountsData } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
-        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following: currenciesData, moneyAmountsData.${os_1.EOL}${e}`);
+    const { currenciesData, moneyAmountsData, priceSetsData, priceSetMoneyAmountsData, } = await Promise.resolve(`${(0, path_1.resolve)(process.cwd(), path)}`).then(s => __importStar(require(s))).catch((e) => {
+        logger?.error(`Failed to load seed data from ${path}. Please, provide a relative path and check that you export the following: priceSetsData, currenciesData, moneyAmountsData and priceSetMoneyAmountsData.${os_1.EOL}${e}`);
         throw e;
     });
     const dbData = utils_1.ModulesSdkUtils.loadDatabaseConfig("pricing", options);
@@ -41,9 +41,11 @@ async function run({ options, logger, path, }) {
     const orm = await utils_1.DALUtils.mikroOrmCreateConnection(dbData, entities, pathToMigrations);
     const manager = orm.em.fork();
     try {
-        logger.info("Inserting currencies & money_amounts");
+        logger.info("Inserting price_sets, currencies & money_amounts");
         await createCurrencies(manager, currenciesData);
         await createMoneyAmounts(manager, moneyAmountsData);
+        await createPriceSets(manager, priceSetsData);
+        await createPriceSetMoneyAmounts(manager, priceSetMoneyAmountsData);
     }
     catch (e) {
         logger.error(`Failed to insert the seed data in the PostgreSQL database ${dbData.clientUrl}.${os_1.EOL}${e}`);
@@ -65,3 +67,17 @@ async function createMoneyAmounts(manager, data) {
     await manager.persistAndFlush(moneyAmounts);
     return moneyAmounts;
 }
+async function createPriceSets(manager, data) {
+    const priceSets = data.map((priceSetData) => {
+        return manager.create(PricingModels.PriceSet, priceSetData);
+    });
+    await manager.persistAndFlush(priceSets);
+    return priceSets;
+}
+async function createPriceSetMoneyAmounts(manager, data) {
+    const priceSetMoneyAmounts = data.map((priceSetMoneyAmountData) => {
+        return manager.create(PricingModels.PriceSetMoneyAmount, priceSetMoneyAmountData);
+    });
+    await manager.persistAndFlush(priceSetMoneyAmounts);
+    return priceSetMoneyAmounts;
+}

package/dist/services/index.d.ts

@@ -1,3 +1,4 @@
 export { default as CurrencyService } from "./currency";
 export { default as MoneyAmountService } from "./money-amount";
+export { default as PriceSetService } from "./price-set";
 export { default as PricingModuleService } from "./pricing-module";

package/dist/services/index.js

@@ -3,10 +3,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PricingModuleService = exports.MoneyAmountService = exports.CurrencyService = void 0;
+exports.PricingModuleService = exports.PriceSetService = exports.MoneyAmountService = exports.CurrencyService = void 0;
 var currency_1 = require("./currency");
 Object.defineProperty(exports, "CurrencyService", { enumerable: true, get: function () { return __importDefault(currency_1).default; } });
 var money_amount_1 = require("./money-amount");
 Object.defineProperty(exports, "MoneyAmountService", { enumerable: true, get: function () { return __importDefault(money_amount_1).default; } });
+var price_set_1 = require("./price-set");
+Object.defineProperty(exports, "PriceSetService", { enumerable: true, get: function () { return __importDefault(price_set_1).default; } });
 var pricing_module_1 = require("./pricing-module");
 Object.defineProperty(exports, "PricingModuleService", { enumerable: true, get: function () { return __importDefault(pricing_module_1).default; } });

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

@@ -0,0 +1,17 @@
+import { Context, DAL, FindConfig, PricingTypes } from "@medusajs/types";
+import { PriceSet } from "../models";
+type InjectedDependencies = {
+    priceSetRepository: DAL.RepositoryService;
+};
+export default class PriceSetService<TEntity extends PriceSet = PriceSet> {
+    protected readonly priceSetRepository_: DAL.RepositoryService;
+    constructor({ priceSetRepository }: InjectedDependencies);
+    retrieve(priceSetId: string, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<TEntity>;
+    list(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<TEntity[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
+    private buildQueryForList;
+    create(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    update(data: PricingTypes.UpdatePriceSetDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    delete(ids: string[], sharedContext?: Context): Promise<void>;
+}
+export {};

package/dist/services/price-set.js

@@ -0,0 +1,96 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("@medusajs/types");
+const utils_1 = require("@medusajs/utils");
+const _models_1 = require("../models");
+class PriceSetService {
+    constructor({ priceSetRepository }) {
+        this.priceSetRepository_ = priceSetRepository;
+    }
+    async retrieve(priceSetId, config = {}, sharedContext = {}) {
+        return (await (0, utils_1.retrieveEntity)({
+            id: priceSetId,
+            entityName: _models_1.PriceSet.name,
+            repository: this.priceSetRepository_,
+            config,
+            sharedContext,
+        }));
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        return (await this.priceSetRepository_.find(this.buildQueryForList(filters, config), sharedContext));
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        return (await this.priceSetRepository_.findAndCount(this.buildQueryForList(filters, config), sharedContext));
+    }
+    buildQueryForList(filters = {}, config = {}) {
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        if (filters.id) {
+            queryOptions.where.id = { $in: filters.id };
+        }
+        return queryOptions;
+    }
+    async create(data, sharedContext = {}) {
+        return (await this.priceSetRepository_.create(data, sharedContext));
+    }
+    async update(data, sharedContext = {}) {
+        return (await this.priceSetRepository_.update(data, sharedContext));
+    }
+    async delete(ids, sharedContext = {}) {
+        await this.priceSetRepository_.delete(ids, sharedContext);
+    }
+}
+exports.default = PriceSetService;
+__decorate([
+    (0, utils_1.InjectManager)("priceSetRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "retrieve", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceSetRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceSetRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "priceSetRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "priceSetRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "update", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.doNotForceTransaction, "priceSetRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetService.prototype, "delete", null);

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

@@ -1,24 +1,36 @@
 import { Context, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, PricingTypes } from "@medusajs/types";
-import { Currency, MoneyAmount } from "../models";
-import { CurrencyService, MoneyAmountService } from ".";
+import { Currency, MoneyAmount, PriceSet } from "../models";
+import { CurrencyService, MoneyAmountService, PriceSetService } from ".";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     currencyService: CurrencyService<any>;
     moneyAmountService: MoneyAmountService<any>;
+    priceSetService: PriceSetService<any>;
 };
-export default class PricingModuleService<TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency> implements PricingTypes.IPricingModuleService {
+type PricingContext = {
+    currency_code?: string;
+};
+export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency> implements PricingTypes.IPricingModuleService {
     protected readonly moduleDeclaration: InternalModuleDeclaration;
     protected baseRepository_: DAL.RepositoryService;
     protected readonly currencyService_: CurrencyService<TCurrency>;
     protected readonly moneyAmountService_: MoneyAmountService<TMoneyAmount>;
-    constructor({ baseRepository, moneyAmountService, currencyService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    protected readonly priceSetService_: PriceSetService<TPriceSet>;
+    constructor({ baseRepository, moneyAmountService, currencyService, priceSetService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
-    retrieve(id: string, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO>;
-    list(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
-    listAndCount(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<[PricingTypes.MoneyAmountDTO[], number]>;
-    create(data: PricingTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
-    update(data: PricingTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
+    calculatePrices(priceSetIds: string[], pricingContext: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSetDTO>;
+    retrieve(id: string, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
+    list(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceSetProps, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceSetDTO[], number]>;
+    create(data: PricingTypes.CreatePriceSetDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
+    update(data: PricingTypes.UpdatePriceSetDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetDTO[]>;
     delete(ids: string[], sharedContext?: Context): Promise<void>;
+    retrieveMoneyAmount(id: string, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO>;
+    listMoneyAmounts(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
+    listAndCountMoneyAmounts(filters?: PricingTypes.FilterableMoneyAmountProps, config?: FindConfig<PricingTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<[PricingTypes.MoneyAmountDTO[], number]>;
+    createMoneyAmounts(data: PricingTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
+    updateMoneyAmounts(data: PricingTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<PricingTypes.MoneyAmountDTO[]>;
+    deleteMoneyAmounts(ids: string[], sharedContext?: Context): Promise<void>;
     retrieveCurrency(code: string, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<PricingTypes.CurrencyDTO>;
     listCurrencies(filters?: PricingTypes.FilterableCurrencyProps, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<PricingTypes.CurrencyDTO[]>;
     listAndCountCurrencies(filters?: PricingTypes.FilterableCurrencyProps, config?: FindConfig<PricingTypes.CurrencyDTO>, sharedContext?: Context): Promise<[PricingTypes.CurrencyDTO[], number]>;

package/dist/services/pricing-module.js

@@ -17,28 +17,99 @@ const utils_1 = require("@medusajs/utils");
 const utils_2 = require("@medusajs/utils");
 const joiner_config_1 = require("../joiner-config");
 class PricingModuleService {
-    constructor({ baseRepository, moneyAmountService, currencyService, }, moduleDeclaration) {
+    constructor({ baseRepository, moneyAmountService, currencyService, priceSetService, }, moduleDeclaration) {
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
         this.currencyService_ = currencyService;
         this.moneyAmountService_ = moneyAmountService;
+        this.priceSetService_ = priceSetService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
+    async calculatePrices(priceSetIds, pricingContext, sharedContext = {}) {
+        // Keeping this whole logic raw in here for now as they will undergo
+        // some changes, will abstract them out once we have a final version
+        const priceSetFilters = {
+            id: priceSetIds,
+        };
+        const priceSets = await this.list(priceSetFilters, {
+            select: [
+                "id",
+                "money_amounts.id",
+                "money_amounts.currency_code",
+                "money_amounts.amount",
+                "money_amounts.min_quantity",
+                "money_amounts.max_quantity",
+            ],
+            relations: ["money_amounts"],
+        }, sharedContext);
+        const calculatedPrices = priceSets.map((priceSet) => {
+            // TODO: This will change with the rules engine selection,
+            // making a DB query directly instead
+            // This should look for a default price when no rules apply
+            // When no price is set, return null values for all cases
+            const selectedMoneyAmount = priceSet.money_amounts?.find((ma) => pricingContext.currency_code &&
+                ma.currency_code === pricingContext.currency_code);
+            return {
+                id: priceSet.id,
+                amount: selectedMoneyAmount?.amount || null,
+                currency_code: selectedMoneyAmount?.currency_code || null,
+                min_quantity: selectedMoneyAmount?.min_quantity || null,
+                max_quantity: selectedMoneyAmount?.max_quantity || null,
+            };
+        });
+        return JSON.parse(JSON.stringify(calculatedPrices));
+    }
     async retrieve(id, config = {}, sharedContext = {}) {
+        const priceSet = await this.priceSetService_.retrieve(id, config, sharedContext);
+        return this.baseRepository_.serialize(priceSet, {
+            populate: true,
+        });
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        const priceSets = await this.priceSetService_.list(filters, config, sharedContext);
+        return this.baseRepository_.serialize(priceSets, {
+            populate: true,
+        });
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        const [priceSets, count] = await this.priceSetService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(priceSets, {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async create(data, sharedContext = {}) {
+        const priceSets = await this.priceSetService_.create(data, sharedContext);
+        return this.baseRepository_.serialize(priceSets, {
+            populate: true,
+        });
+    }
+    async update(data, sharedContext = {}) {
+        const priceSets = await this.priceSetService_.update(data, sharedContext);
+        return this.baseRepository_.serialize(priceSets, {
+            populate: true,
+        });
+    }
+    async delete(ids, sharedContext = {}) {
+        await this.priceSetService_.delete(ids, sharedContext);
+    }
+    async retrieveMoneyAmount(id, config = {}, sharedContext = {}) {
         const moneyAmount = await this.moneyAmountService_.retrieve(id, config, sharedContext);
         return this.baseRepository_.serialize(moneyAmount, {
             populate: true,
         });
     }
-    async list(filters = {}, config = {}, sharedContext = {}) {
+    async listMoneyAmounts(filters = {}, config = {}, sharedContext = {}) {
         const moneyAmounts = await this.moneyAmountService_.list(filters, config, sharedContext);
         return this.baseRepository_.serialize(moneyAmounts, {
             populate: true,
         });
     }
-    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+    async listAndCountMoneyAmounts(filters = {}, config = {}, sharedContext = {}) {
         const [moneyAmounts, count] = await this.moneyAmountService_.listAndCount(filters, config, sharedContext);
         return [
             await this.baseRepository_.serialize(moneyAmounts, {
@@ -47,19 +118,19 @@ class PricingModuleService {
             count,
         ];
     }
-    async create(data, sharedContext = {}) {
+    async createMoneyAmounts(data, sharedContext = {}) {
         const moneyAmounts = await this.moneyAmountService_.create(data, sharedContext);
         return this.baseRepository_.serialize(moneyAmounts, {
             populate: true,
         });
     }
-    async update(data, sharedContext = {}) {
+    async updateMoneyAmounts(data, sharedContext = {}) {
         const moneyAmounts = await this.moneyAmountService_.update(data, sharedContext);
         return this.baseRepository_.serialize(moneyAmounts, {
             populate: true,
         });
     }
-    async delete(ids, sharedContext = {}) {
+    async deleteMoneyAmounts(ids, sharedContext = {}) {
         await this.moneyAmountService_.delete(ids, sharedContext);
     }
     async retrieveCurrency(code, config = {}, sharedContext = {}) {
@@ -100,6 +171,13 @@ class PricingModuleService {
     }
 }
 exports.default = PricingModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "calculatePrices", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -142,6 +220,48 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "delete", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "retrieveMoneyAmount", 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, "listMoneyAmounts", 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, "listAndCountMoneyAmounts", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "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)(utils_2.shouldForceTransaction, "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)(utils_2.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "deleteMoneyAmounts", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@medusajs/pricing",
-  "version": "0.0.2",
+  "version": "0.0.3-next-20230912130318",
   "description": "Medusa Pricing module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,9 +47,9 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@medusajs/modules-sdk": "^1.10.0",
-    "@medusajs/types": "^1.11.0",
-    "@medusajs/utils": "^1.10.0",
+    "@medusajs/modules-sdk": "1.11.0-next-20230912130318",
+    "@medusajs/types": "1.11.1-next-20230912130318",
+    "@medusajs/utils": "1.10.1-next-20230912130318",
     "@mikro-orm/core": "5.7.12",
     "@mikro-orm/migrations": "5.7.12",
     "@mikro-orm/postgresql": "5.7.12",

package/dist/migrations/Migration20230830085850.d.ts

@@ -1,4 +0,0 @@
-import { Migration } from '@mikro-orm/migrations';
-export declare class Migration20230830085850 extends Migration {
-    up(): Promise<void>;
-}

package/dist/migrations/Migration20230830085850.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Migration20230830085850 = void 0;
-const migrations_1 = require("@mikro-orm/migrations");
-class Migration20230830085850 extends migrations_1.Migration {
-    async up() {
-        this.addSql('create table "currency" ("code" text not null, "symbol" text not null, "symbol_native" text not null, "name" text not null, constraint "currency_pkey" primary key ("code"));');
-        this.addSql('create table "money_amount" ("id" text not null, "currency_code" text null, "amount" numeric null, "min_quantity" numeric null, "max_quantity" numeric null, constraint "money_amount_pkey" primary key ("id"));');
-        this.addSql('create index "IDX_money_amount_currency_code" on "money_amount" ("currency_code");');
-        this.addSql('alter table "money_amount" add constraint "money_amount_currency_code_foreign" foreign key ("currency_code") references "currency" ("code") on update cascade on delete set null;');
-    }
-}
-exports.Migration20230830085850 = Migration20230830085850;