@medusajs/pricing 0.0.3 → 0.0.4-next-20230929123725

package/dist/services/money-amount.js

@@ -30,17 +30,12 @@ class MoneyAmountService {
         }));
     }
     async list(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.moneyAmountRepository_.find(this.buildQueryForList(filters, config), sharedContext));
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return (await this.moneyAmountRepository_.find(queryOptions, sharedContext));
     }
     async listAndCount(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.moneyAmountRepository_.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;
+        return (await this.moneyAmountRepository_.findAndCount(queryOptions, sharedContext));
     }
     async create(data, sharedContext = {}) {
         return (await this.moneyAmountRepository_.create(data, sharedContext));

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

@@ -0,0 +1,16 @@
+import { Context, DAL, FindConfig, PricingTypes } from "@medusajs/types";
+import { PriceRule } from "../models";
+type InjectedDependencies = {
+    priceRuleRepository: DAL.RepositoryService;
+};
+export default class PriceRuleService<TEntity extends PriceRule = PriceRule> {
+    protected readonly priceRuleRepository_: DAL.RepositoryService;
+    constructor({ priceRuleRepository }: InjectedDependencies);
+    retrieve(priceRuleId: string, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<TEntity>;
+    list(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<TEntity[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
+    create(data: PricingTypes.CreatePriceRuleDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    update(data: PricingTypes.UpdatePriceRuleDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    delete(ids: string[], sharedContext?: Context): Promise<void>;
+}
+export {};

package/dist/services/price-rule.js

@@ -0,0 +1,91 @@
+"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 PriceRuleService {
+    constructor({ priceRuleRepository }) {
+        this.priceRuleRepository_ = priceRuleRepository;
+    }
+    async retrieve(priceRuleId, config = {}, sharedContext = {}) {
+        return (await (0, utils_1.retrieveEntity)({
+            id: priceRuleId,
+            entityName: _models_1.PriceRule.name,
+            repository: this.priceRuleRepository_,
+            config,
+            sharedContext,
+        }));
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        const queryConfig = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return (await this.priceRuleRepository_.find(queryConfig, sharedContext));
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        const queryConfig = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return (await this.priceRuleRepository_.findAndCount(queryConfig, sharedContext));
+    }
+    async create(data, sharedContext = {}) {
+        return (await this.priceRuleRepository_.create(data, sharedContext));
+    }
+    async update(data, sharedContext = {}) {
+        return (await this.priceRuleRepository_.update(data, sharedContext));
+    }
+    async delete(ids, sharedContext = {}) {
+        await this.priceRuleRepository_.delete(ids, sharedContext);
+    }
+}
+exports.default = PriceRuleService;
+__decorate([
+    (0, utils_1.InjectManager)("priceRuleRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "retrieve", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceRuleRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceRuleRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "priceRuleRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "priceRuleRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "update", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.doNotForceTransaction, "priceRuleRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceRuleService.prototype, "delete", null);

package/dist/services/price-set-money-amount-rules.d.ts

@@ -0,0 +1,17 @@
+import { Context, DAL, FindConfig, PricingTypes } from "@medusajs/types";
+import { PriceSetMoneyAmountRules } from "../models";
+type InjectedDependencies = {
+    priceSetMoneyAmountRulesRepository: DAL.RepositoryService;
+};
+export default class PriceSetMoneyAmountRulesService<TEntity extends PriceSetMoneyAmountRules = PriceSetMoneyAmountRules> {
+    protected readonly priceSetMoneyAmountRulesRepository_: DAL.RepositoryService;
+    constructor({ priceSetMoneyAmountRulesRepository }: InjectedDependencies);
+    retrieve(priceSetMoneyAmountRulesId: string, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<TEntity>;
+    list(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<TEntity[]>;
+    listAndCount(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
+    private buildQueryForList;
+    create(data: PricingTypes.CreatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    update(data: PricingTypes.UpdatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<TEntity[]>;
+    delete(ids: string[], sharedContext?: Context): Promise<void>;
+}
+export {};

package/dist/services/price-set-money-amount-rules.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");
+const utils_2 = require("@medusajs/utils");
+class PriceSetMoneyAmountRulesService {
+    constructor({ priceSetMoneyAmountRulesRepository }) {
+        this.priceSetMoneyAmountRulesRepository_ =
+            priceSetMoneyAmountRulesRepository;
+    }
+    async retrieve(priceSetMoneyAmountRulesId, config = {}, sharedContext = {}) {
+        return (await (0, utils_1.retrieveEntity)({
+            id: priceSetMoneyAmountRulesId,
+            identifierColumn: "id",
+            entityName: _models_1.PriceSetMoneyAmountRules.name,
+            repository: this.priceSetMoneyAmountRulesRepository_,
+            config,
+            sharedContext,
+        }));
+    }
+    async list(filters = {}, config = {}, sharedContext = {}) {
+        return (await this.priceSetMoneyAmountRulesRepository_.find(this.buildQueryForList(filters, config), sharedContext));
+    }
+    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
+        return (await this.priceSetMoneyAmountRulesRepository_.findAndCount(this.buildQueryForList(filters, config), sharedContext));
+    }
+    buildQueryForList(filters = {}, config = {}) {
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return queryOptions;
+    }
+    async create(data, sharedContext = {}) {
+        return (await this.priceSetMoneyAmountRulesRepository_.create(data, sharedContext));
+    }
+    async update(data, sharedContext = {}) {
+        return (await this.priceSetMoneyAmountRulesRepository_.update(data, sharedContext));
+    }
+    async delete(ids, sharedContext = {}) {
+        await this.priceSetMoneyAmountRulesRepository_.delete(ids, sharedContext);
+    }
+}
+exports.default = PriceSetMoneyAmountRulesService;
+__decorate([
+    (0, utils_1.InjectManager)("priceSetMoneyAmountRulesRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "retrieve", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceSetMoneyAmountRulesRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "list", null);
+__decorate([
+    (0, utils_1.InjectManager)("priceSetMoneyAmountRulesRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "listAndCount", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "priceSetMoneyAmountRulesRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.shouldForceTransaction, "priceSetMoneyAmountRulesRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "update", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_2.doNotForceTransaction, "priceSetMoneyAmountRulesRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PriceSetMoneyAmountRulesService.prototype, "delete", null);

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

@@ -9,7 +9,6 @@ export default class PriceSetService<TEntity extends PriceSet = PriceSet> {
     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>;

package/dist/services/price-set.js

@@ -29,17 +29,12 @@ class PriceSetService {
         }));
     }
     async list(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.priceSetRepository_.find(this.buildQueryForList(filters, config), sharedContext));
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return (await this.priceSetRepository_.find(queryOptions, 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;
+        return (await this.priceSetRepository_.findAndCount(queryOptions, sharedContext));
     }
     async create(data, sharedContext = {}) {
         return (await this.priceSetRepository_.create(data, sharedContext));

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

@@ -1,21 +1,25 @@
 import { Context, DAL, FindConfig, InternalModuleDeclaration, ModuleJoinerConfig, PricingContext, PricingFilters, PricingTypes } from "@medusajs/types";
-import { Currency, MoneyAmount, PriceSet, RuleType } from "../models";
-import { CurrencyService, MoneyAmountService, PriceSetService, RuleTypeService } from ".";
+import { Currency, MoneyAmount, PriceRule, PriceSet, PriceSetMoneyAmountRules, RuleType } from "../models";
+import { CurrencyService, MoneyAmountService, PriceRuleService, PriceSetMoneyAmountRulesService, PriceSetService, RuleTypeService } from ".";
 type InjectedDependencies = {
     baseRepository: DAL.RepositoryService;
     currencyService: CurrencyService<any>;
     moneyAmountService: MoneyAmountService<any>;
-    ruleTypeService: RuleTypeService<any>;
     priceSetService: PriceSetService<any>;
+    priceSetMoneyAmountRulesService: PriceSetMoneyAmountRulesService<any>;
+    ruleTypeService: RuleTypeService<any>;
+    priceRuleService: PriceRuleService<any>;
 };
-export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency, TRuleType extends RuleType = RuleType> implements PricingTypes.IPricingModuleService {
+export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet, TMoneyAmount extends MoneyAmount = MoneyAmount, TCurrency extends Currency = Currency, TRuleType extends RuleType = RuleType, TPriceSetMoneyAmountRules extends PriceSetMoneyAmountRules = PriceSetMoneyAmountRules, TPriceRule extends PriceRule = PriceRule> implements PricingTypes.IPricingModuleService {
     protected readonly moduleDeclaration: InternalModuleDeclaration;
     protected baseRepository_: DAL.RepositoryService;
     protected readonly currencyService_: CurrencyService<TCurrency>;
     protected readonly moneyAmountService_: MoneyAmountService<TMoneyAmount>;
     protected readonly ruleTypeService_: RuleTypeService<TRuleType>;
     protected readonly priceSetService_: PriceSetService<TPriceSet>;
-    constructor({ baseRepository, moneyAmountService, currencyService, ruleTypeService, priceSetService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
+    protected readonly priceSetMoneyAmountRulesService_: PriceSetMoneyAmountRulesService<TPriceSetMoneyAmountRules>;
+    protected readonly priceRuleService_: PriceRuleService<TPriceRule>;
+    constructor({ baseRepository, moneyAmountService, currencyService, ruleTypeService, priceSetService, priceSetMoneyAmountRulesService, priceRuleService, }: InjectedDependencies, moduleDeclaration: InternalModuleDeclaration);
     __joinerConfig(): ModuleJoinerConfig;
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<PricingTypes.CalculatedPriceSetDTO>;
     retrieve(id: string, config?: FindConfig<PricingTypes.PriceSetDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetDTO>;
@@ -42,5 +46,17 @@ export default class PricingModuleService<TPriceSet extends PriceSet = PriceSet,
     createRuleTypes(data: PricingTypes.CreateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
     updateRuleTypes(data: PricingTypes.UpdateRuleTypeDTO[], sharedContext?: Context): Promise<PricingTypes.RuleTypeDTO[]>;
     deleteRuleTypes(ruleTypes: string[], sharedContext?: Context): Promise<void>;
+    retrievePriceSetMoneyAmountRules(id: string, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO>;
+    listPriceSetMoneyAmountRules(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
+    listAndCountPriceSetMoneyAmountRules(filters?: PricingTypes.FilterablePriceSetMoneyAmountRulesProps, config?: FindConfig<PricingTypes.PriceSetMoneyAmountRulesDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceSetMoneyAmountRulesDTO[], number]>;
+    createPriceSetMoneyAmountRules(data: PricingTypes.CreatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
+    updatePriceSetMoneyAmountRules(data: PricingTypes.UpdatePriceSetMoneyAmountRulesDTO[], sharedContext?: Context): Promise<PricingTypes.PriceSetMoneyAmountRulesDTO[]>;
+    deletePriceSetMoneyAmountRules(ids: string[], sharedContext?: Context): Promise<void>;
+    retrievePriceRule(id: string, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO>;
+    listPriceRules(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
+    listAndCountPriceRules(filters?: PricingTypes.FilterablePriceRuleProps, config?: FindConfig<PricingTypes.PriceRuleDTO>, sharedContext?: Context): Promise<[PricingTypes.PriceRuleDTO[], number]>;
+    createPriceRules(data: PricingTypes.CreatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
+    updatePriceRules(data: PricingTypes.UpdatePriceRuleDTO[], sharedContext?: Context): Promise<PricingTypes.PriceRuleDTO[]>;
+    deletePriceRules(priceRuleIds: string[], sharedContext?: Context): Promise<void>;
 }
 export {};

package/dist/services/pricing-module.js

@@ -16,47 +16,95 @@ const types_1 = require("@medusajs/types");
 const utils_1 = require("@medusajs/utils");
 const joiner_config_1 = require("../joiner-config");
 class PricingModuleService {
-    constructor({ baseRepository, moneyAmountService, currencyService, ruleTypeService, priceSetService, }, moduleDeclaration) {
+    constructor({ baseRepository, moneyAmountService, currencyService, ruleTypeService, priceSetService, priceSetMoneyAmountRulesService, priceRuleService, }, moduleDeclaration) {
         this.moduleDeclaration = moduleDeclaration;
         this.baseRepository_ = baseRepository;
         this.currencyService_ = currencyService;
         this.moneyAmountService_ = moneyAmountService;
         this.ruleTypeService_ = ruleTypeService;
         this.priceSetService_ = priceSetService;
+        this.priceSetMoneyAmountRulesService_ = priceSetMoneyAmountRulesService;
+        this.ruleTypeService_ = ruleTypeService;
+        this.priceRuleService_ = priceRuleService;
     }
     __joinerConfig() {
         return joiner_config_1.joinerConfig;
     }
     async calculatePrices(pricingFilters, pricingContext = { context: {} }, sharedContext = {}) {
+        const manager = sharedContext.manager;
+        const knex = manager.getKnex();
         // 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 context = pricingContext.context || {};
-        const priceSetFilters = {
-            id: pricingFilters.id,
-        };
-        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) => context.currency_code && ma.currency_code === context.currency_code);
+        // Quantity is used to scope money amounts based on min_quantity and max_quantity.
+        // We should potentially think of reserved words in pricingContext that can't be used in rules
+        // or have a separate pricing options that accept things like quantity, price_list_id and other
+        // pricing module features
+        const quantity = context.quantity;
+        delete context.quantity;
+        // Gets all the price set money amounts where rules match for each of the contexts
+        // that the price set is configured for
+        const psmaSubQueryKnex = knex({
+            psma: "price_set_money_amount",
+        })
+            .select({
+            id: "psma.id",
+            price_set_id: "psma.price_set_id",
+            money_amount_id: "psma.money_amount_id",
+            number_rules: "psma.number_rules",
+        })
+            .join("price_rule as pr", "pr.price_set_money_amount_id", "psma.id")
+            .join("rule_type as rt", "rt.id", "pr.rule_type_id")
+            .orderBy("number_rules", "desc");
+        for (const [key, value] of Object.entries(context)) {
+            psmaSubQueryKnex.orWhere({
+                "rt.rule_attribute": key,
+                "pr.value": value,
+            });
+        }
+        psmaSubQueryKnex
+            .groupBy("psma.id")
+            .having(knex.raw("count(DISTINCT rt.rule_attribute) = psma.number_rules"));
+        const priceSetQueryKnex = knex({
+            ps: "price_set",
+        })
+            .select({
+            id: "ps.id",
+            amount: "ma.amount",
+            min_quantity: "ma.min_quantity",
+            max_quantity: "ma.max_quantity",
+            currency_code: "ma.currency_code",
+            default_priority: "rt.default_priority",
+            number_rules: "psma.number_rules",
+        })
+            .join(psmaSubQueryKnex.as("psma"), "psma.price_set_id", "ps.id")
+            .join("money_amount as ma", "ma.id", "psma.money_amount_id")
+            .join("price_rule as pr", "pr.price_set_money_amount_id", "psma.id")
+            .join("rule_type as rt", "rt.id", "pr.rule_type_id")
+            .whereIn("ps.id", pricingFilters.id)
+            .orderBy([
+            { column: "number_rules", order: "desc" },
+            { column: "default_priority", order: "desc" },
+        ]);
+        if (quantity) {
+            priceSetQueryKnex.where("ma.min_quantity", "<=", quantity);
+            priceSetQueryKnex.andWhere("ma.max_quantity", ">=", quantity);
+        }
+        const isContextPresent = Object.entries(context).length;
+        // Only if the context is present do we need to query the database.
+        const queryBuilderResults = isContextPresent ? await priceSetQueryKnex : [];
+        const pricesSetPricesMap = (0, utils_1.groupBy)(queryBuilderResults, "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 number_rules first for exact match and then deafult_priority of the rule_type
+            // inject custom price selection here
+            const price = pricesSetPricesMap.get(priceSetId)?.[0];
             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,
+                id: priceSetId,
+                amount: price?.amount || null,
+                currency_code: price?.currency_code || null,
+                min_quantity: price?.min_quantity || null,
+                max_quantity: price?.max_quantity || null,
             };
         });
         return JSON.parse(JSON.stringify(calculatedPrices));
@@ -205,6 +253,78 @@ class PricingModuleService {
     async deleteRuleTypes(ruleTypes, sharedContext = {}) {
         await this.ruleTypeService_.delete(ruleTypes, sharedContext);
     }
+    async retrievePriceSetMoneyAmountRules(id, config = {}, sharedContext = {}) {
+        const record = await this.priceSetMoneyAmountRulesService_.retrieve(id, config, sharedContext);
+        return this.baseRepository_.serialize(record, {
+            populate: true,
+        });
+    }
+    async listPriceSetMoneyAmountRules(filters = {}, config = {}, sharedContext = {}) {
+        const records = await this.priceSetMoneyAmountRulesService_.list(filters, config, sharedContext);
+        return this.baseRepository_.serialize(records, {
+            populate: true,
+        });
+    }
+    async listAndCountPriceSetMoneyAmountRules(filters = {}, config = {}, sharedContext = {}) {
+        const [records, count] = await this.priceSetMoneyAmountRulesService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(records, {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async createPriceSetMoneyAmountRules(data, sharedContext = {}) {
+        const records = await this.priceSetMoneyAmountRulesService_.create(data, sharedContext);
+        return this.baseRepository_.serialize(records, {
+            populate: true,
+        });
+    }
+    async updatePriceSetMoneyAmountRules(data, sharedContext = {}) {
+        const records = await this.priceSetMoneyAmountRulesService_.update(data, sharedContext);
+        return this.baseRepository_.serialize(records, {
+            populate: true,
+        });
+    }
+    async deletePriceSetMoneyAmountRules(ids, sharedContext = {}) {
+        await this.priceSetMoneyAmountRulesService_.delete(ids, sharedContext);
+    }
+    async retrievePriceRule(id, config = {}, sharedContext = {}) {
+        const priceRule = await this.priceRuleService_.retrieve(id, config, sharedContext);
+        return this.baseRepository_.serialize(priceRule, {
+            populate: true,
+        });
+    }
+    async listPriceRules(filters = {}, config = {}, sharedContext = {}) {
+        const priceRules = await this.priceRuleService_.list(filters, config, sharedContext);
+        return this.baseRepository_.serialize(priceRules, {
+            populate: true,
+        });
+    }
+    async listAndCountPriceRules(filters = {}, config = {}, sharedContext = {}) {
+        const [priceRules, count] = await this.priceRuleService_.listAndCount(filters, config, sharedContext);
+        return [
+            await this.baseRepository_.serialize(priceRules, {
+                populate: true,
+            }),
+            count,
+        ];
+    }
+    async createPriceRules(data, sharedContext = {}) {
+        const priceRules = await this.priceRuleService_.create(data, sharedContext);
+        return this.baseRepository_.serialize(priceRules, {
+            populate: true,
+        });
+    }
+    async updatePriceRules(data, sharedContext = {}) {
+        const priceRules = await this.priceRuleService_.update(data, sharedContext);
+        return this.baseRepository_.serialize(priceRules, {
+            populate: true,
+        });
+    }
+    async deletePriceRules(priceRuleIds, sharedContext = {}) {
+        await this.priceRuleService_.delete(priceRuleIds, sharedContext);
+    }
 }
 exports.default = PricingModuleService;
 __decorate([
@@ -382,3 +502,87 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], PricingModuleService.prototype, "deleteRuleTypes", 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, "retrievePriceSetMoneyAmountRules", 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, "listPriceSetMoneyAmountRules", 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, "listAndCountPriceSetMoneyAmountRules", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "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)(utils_1.shouldForceTransaction, "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)(utils_1.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "deletePriceSetMoneyAmountRules", 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, "retrievePriceRule", 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, "listPriceRules", 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, "listAndCountPriceRules", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)(utils_1.shouldForceTransaction, "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)(utils_1.shouldForceTransaction, "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.InjectTransactionManager)(utils_1.shouldForceTransaction, "baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], PricingModuleService.prototype, "deletePriceRules", null);

package/dist/services/rule-type.d.ts

@@ -9,7 +9,6 @@ export default class RuleTypeService<TEntity extends RuleType = RuleType> {
     retrieve(ruleTypeId: string, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<TEntity>;
     list(filters?: PricingTypes.FilterableRuleTypeProps, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<TEntity[]>;
     listAndCount(filters?: PricingTypes.FilterableRuleTypeProps, config?: FindConfig<PricingTypes.RuleTypeDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
-    private buildQueryForList;
     create(data: PricingTypes.CreateRuleTypeDTO[], sharedContext?: Context): Promise<TEntity[]>;
     update(data: PricingTypes.UpdateRuleTypeDTO[], sharedContext?: Context): Promise<TEntity[]>;
     delete(ids: string[], sharedContext?: Context): Promise<void>;

package/dist/services/rule-type.js

@@ -31,17 +31,12 @@ class RuleTypeService {
         }));
     }
     async list(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.ruleTypeRepository_.find(this.buildQueryForList(filters, config), sharedContext));
+        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
+        return (await this.ruleTypeRepository_.find(queryOptions, sharedContext));
     }
     async listAndCount(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.ruleTypeRepository_.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;
+        return (await this.ruleTypeRepository_.findAndCount(queryOptions, sharedContext));
     }
     async create(data, sharedContext = {}) {
         return (await this.ruleTypeRepository_.create(data, sharedContext));