@medusajs/pricing 0.1.7 → 0.1.8-next-20240124093206

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { moduleDefinition } from "./module-definition";
+import { moduleDefinition, revertMigration, runMigrations } from "./module-definition";
 export default moduleDefinition;
-export * from "./scripts";
+export { revertMigration, runMigrations };
 export * from "./initialize";
-export * from "./types";
-export * from "./loaders";
 export * from "./models";
 export * from "./services";
+export * from "./types";

package/dist/index.js

@@ -14,11 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrations = exports.revertMigration = void 0;
 const module_definition_1 = require("./module-definition");
+Object.defineProperty(exports, "revertMigration", { enumerable: true, get: function () { return module_definition_1.revertMigration; } });
+Object.defineProperty(exports, "runMigrations", { enumerable: true, get: function () { return module_definition_1.runMigrations; } });
 exports.default = module_definition_1.moduleDefinition;
-__exportStar(require("./scripts"), exports);
 __exportStar(require("./initialize"), exports);
-__exportStar(require("./types"), exports);
-__exportStar(require("./loaders"), exports);
+// TODO: remove export from models and services
 __exportStar(require("./models"), exports);
 __exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);

package/dist/loaders/container.d.ts

@@ -1,4 +1,2 @@
-import { LoaderOptions } from "@medusajs/modules-sdk";
-import { ModulesSdkTypes } from "@medusajs/types";
-declare const _default: ({ container, options, }: LoaderOptions<ModulesSdkTypes.ModuleServiceInitializeOptions | ModulesSdkTypes.ModuleServiceInitializeCustomDataLayerOptions>) => Promise<void>;
+declare const _default: ({ container, options }: import("@medusajs/types").LoaderOptions) => Promise<void>;
 export default _default;

package/dist/loaders/container.js

@@ -23,50 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const defaultRepositories = __importStar(require("../repositories"));
-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)(defaultServices.CurrencyService).singleton(),
-        moneyAmountService: (0, awilix_1.asClass)(defaultServices.MoneyAmountService).singleton(),
-        priceSetService: (0, awilix_1.asClass)(defaultServices.PriceSetService).singleton(),
-        ruleTypeService: (0, awilix_1.asClass)(defaultServices.RuleTypeService).singleton(),
-        priceSetMoneyAmountRulesService: (0, awilix_1.asClass)(defaultServices.PriceSetMoneyAmountRulesService).singleton(),
-        priceRuleService: (0, awilix_1.asClass)(defaultServices.PriceRuleService).singleton(),
-        priceSetRuleTypeService: (0, awilix_1.asClass)(defaultServices.PriceSetRuleTypeService).singleton(),
-        priceSetMoneyAmountService: (0, awilix_1.asClass)(defaultServices.PriceSetMoneyAmountService).singleton(),
-        priceListService: (0, awilix_1.asClass)(defaultServices.PriceListService).singleton(),
-        priceListRuleService: (0, awilix_1.asClass)(defaultServices.PriceListRuleService).singleton(),
-        priceListRuleValueService: (0, awilix_1.asClass)(defaultServices.PriceListRuleValueService).singleton(),
-    });
-    if (customRepositories) {
-        (0, utils_1.loadCustomRepositories)({
-            defaultRepositories,
-            customRepositories,
-            container,
-        });
-    }
-    else {
-        loadDefaultRepositories({ container });
-    }
-};
-function loadDefaultRepositories({ container }) {
-    container.register({
-        baseRepository: (0, awilix_1.asClass)(defaultRepositories.BaseRepository).singleton(),
-        pricingRepository: (0, awilix_1.asClass)(defaultRepositories.PricingRepository).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(),
-        ruleTypeRepository: (0, awilix_1.asClass)(defaultRepositories.RuleTypeRepository).singleton(),
-        priceSetMoneyAmountRulesRepository: (0, awilix_1.asClass)(defaultRepositories.PriceSetMoneyAmountRulesRepository).singleton(),
-        priceRuleRepository: (0, awilix_1.asClass)(defaultRepositories.PriceRuleRepository).singleton(),
-        priceSetRuleTypeRepository: (0, awilix_1.asClass)(defaultRepositories.PriceSetRuleTypeRepository).singleton(),
-        priceSetMoneyAmountRepository: (0, awilix_1.asClass)(defaultRepositories.PriceSetMoneyAmountRepository).singleton(),
-        priceListRepository: (0, awilix_1.asClass)(defaultRepositories.PriceListRepository).singleton(),
-        priceListRuleRepository: (0, awilix_1.asClass)(defaultRepositories.PriceListRuleRepository).singleton(),
-        priceListRuleValueRepository: (0, awilix_1.asClass)(defaultRepositories.PriceListRuleValueRepository).singleton(),
-    });
-}
+const ModuleModels = __importStar(require("../models"));
+const ModuleRepositories = __importStar(require("../repositories"));
+const ModuleServices = __importStar(require("../services"));
+exports.default = utils_1.ModulesSdkUtils.moduleContainerLoaderFactory({
+    moduleModels: ModuleModels,
+    moduleRepositories: ModuleRepositories,
+    moduleServices: ModuleServices,
+});

package/dist/module-definition.d.ts

@@ -1,2 +1,4 @@
 import { ModuleExports } from "@medusajs/types";
+export declare const runMigrations: ({ options, logger, }?: Pick<import("@medusajs/modules-sdk").LoaderOptions<import("@medusajs/modules-sdk").ModuleServiceInitializeOptions>, "options" | "logger"> | undefined) => Promise<void>;
+export declare const revertMigration: ({ options, logger, }?: Pick<import("@medusajs/modules-sdk").LoaderOptions<import("@medusajs/modules-sdk").ModuleServiceInitializeOptions>, "options" | "logger"> | undefined) => Promise<void>;
 export declare const moduleDefinition: ModuleExports;

package/dist/module-definition.js

@@ -1,15 +1,50 @@
 "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;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.moduleDefinition = void 0;
+exports.moduleDefinition = exports.revertMigration = exports.runMigrations = void 0;
+const modules_sdk_1 = require("@medusajs/modules-sdk");
+const utils_1 = require("@medusajs/utils");
+const Models = __importStar(require("./models"));
 const _services_1 = require("./services");
 const connection_1 = __importDefault(require("./loaders/connection"));
 const container_1 = __importDefault(require("./loaders/container"));
+const migrationScriptOptions = {
+    moduleName: modules_sdk_1.Modules.PRICING,
+    models: Models,
+    pathToMigrations: __dirname + "/migrations",
+};
+exports.runMigrations = utils_1.ModulesSdkUtils.buildMigrationScript(migrationScriptOptions);
+exports.revertMigration = utils_1.ModulesSdkUtils.buildRevertMigrationScript(migrationScriptOptions);
 const service = _services_1.PricingModuleService;
 const loaders = [container_1.default, connection_1.default];
 exports.moduleDefinition = {
     service,
     loaders,
+    runMigrations: exports.runMigrations,
+    revertMigration: exports.revertMigration,
 };

package/dist/repositories/index.d.ts

@@ -1,13 +1,2 @@
 export { MikroOrmBaseRepository as BaseRepository } from "@medusajs/utils";
-export { CurrencyRepository } from "./currency";
-export { MoneyAmountRepository } from "./money-amount";
-export { PriceListRepository } from "./price-list";
-export { PriceListRuleRepository } from "./price-list-rule";
-export { PriceListRuleValueRepository } from "./price-list-rule-value";
-export { PriceRuleRepository } from "./price-rule";
-export { PriceSetRepository } from "./price-set";
-export { PriceSetMoneyAmountRepository } from "./price-set-money-amount";
-export { PriceSetMoneyAmountRulesRepository } from "./price-set-money-amount-rules";
-export { PriceSetRuleTypeRepository } from "./price-set-rule-type";
 export { PricingRepository } from "./pricing";
-export { RuleTypeRepository } from "./rule-type";

package/dist/repositories/index.js

@@ -1,29 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RuleTypeRepository = exports.PricingRepository = exports.PriceSetRuleTypeRepository = exports.PriceSetMoneyAmountRulesRepository = exports.PriceSetMoneyAmountRepository = exports.PriceSetRepository = exports.PriceRuleRepository = exports.PriceListRuleValueRepository = exports.PriceListRuleRepository = exports.PriceListRepository = exports.MoneyAmountRepository = exports.CurrencyRepository = exports.BaseRepository = void 0;
+exports.PricingRepository = 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_list_1 = require("./price-list");
-Object.defineProperty(exports, "PriceListRepository", { enumerable: true, get: function () { return price_list_1.PriceListRepository; } });
-var price_list_rule_1 = require("./price-list-rule");
-Object.defineProperty(exports, "PriceListRuleRepository", { enumerable: true, get: function () { return price_list_rule_1.PriceListRuleRepository; } });
-var price_list_rule_value_1 = require("./price-list-rule-value");
-Object.defineProperty(exports, "PriceListRuleValueRepository", { enumerable: true, get: function () { return price_list_rule_value_1.PriceListRuleValueRepository; } });
-var price_rule_1 = require("./price-rule");
-Object.defineProperty(exports, "PriceRuleRepository", { enumerable: true, get: function () { return price_rule_1.PriceRuleRepository; } });
-var price_set_1 = require("./price-set");
-Object.defineProperty(exports, "PriceSetRepository", { enumerable: true, get: function () { return price_set_1.PriceSetRepository; } });
-var price_set_money_amount_1 = require("./price-set-money-amount");
-Object.defineProperty(exports, "PriceSetMoneyAmountRepository", { enumerable: true, get: function () { return price_set_money_amount_1.PriceSetMoneyAmountRepository; } });
-var price_set_money_amount_rules_1 = require("./price-set-money-amount-rules");
-Object.defineProperty(exports, "PriceSetMoneyAmountRulesRepository", { enumerable: true, get: function () { return price_set_money_amount_rules_1.PriceSetMoneyAmountRulesRepository; } });
-var price_set_rule_type_1 = require("./price-set-rule-type");
-Object.defineProperty(exports, "PriceSetRuleTypeRepository", { enumerable: true, get: function () { return price_set_rule_type_1.PriceSetRuleTypeRepository; } });
 var pricing_1 = require("./pricing");
 Object.defineProperty(exports, "PricingRepository", { enumerable: true, get: function () { return pricing_1.PricingRepository; } });
-var rule_type_1 = require("./rule-type");
-Object.defineProperty(exports, "RuleTypeRepository", { enumerable: true, get: function () { return rule_type_1.RuleTypeRepository; } });

package/dist/repositories/pricing.d.ts

@@ -1,10 +1,6 @@
 import { MikroOrmBase } from "@medusajs/utils";
 import { CalculatedPriceSetDTO, Context, PricingContext, PricingFilters, PricingRepositoryService } from "@medusajs/types";
-import { SqlEntityManager } from "@mikro-orm/postgresql";
 export declare class PricingRepository extends MikroOrmBase implements PricingRepositoryService {
-    protected readonly manager_: SqlEntityManager;
-    constructor({ manager }: {
-        manager: SqlEntityManager;
-    });
+    constructor();
     calculatePrices(pricingFilters: PricingFilters, pricingContext?: PricingContext, sharedContext?: Context): Promise<CalculatedPriceSetDTO[]>;
 }

package/dist/repositories/pricing.js

@@ -3,11 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PricingRepository = void 0;
 const utils_1 = require("@medusajs/utils");
 class PricingRepository extends utils_1.MikroOrmBase {
-    constructor({ manager }) {
+    constructor() {
         // @ts-ignore
         // eslint-disable-next-line prefer-rest-params
         super(...arguments);
-        this.manager_ = manager;
     }
     async calculatePrices(pricingFilters, pricingContext = { context: {} }, sharedContext = {}) {
         const manager = this.getActiveManager(sharedContext);

package/dist/services/currency.d.ts

@@ -1,18 +1,18 @@
-import { Context, DAL, FindConfig } from "@medusajs/types";
+import { DAL } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
 import { Currency } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     currencyRepository: DAL.RepositoryService;
 };
-export default class CurrencyService<TEntity extends Currency = Currency> {
-    protected readonly currencyRepository_: DAL.RepositoryService;
-    constructor({ currencyRepository }: InjectedDependencies);
-    retrieve(currencyCode: string, config?: FindConfig<ServiceTypes.CurrencyDTO>, sharedContext?: Context): Promise<TEntity>;
-    list(filters?: ServiceTypes.FilterableCurrencyProps, config?: FindConfig<ServiceTypes.CurrencyDTO>, sharedContext?: Context): Promise<TEntity[]>;
-    listAndCount(filters?: ServiceTypes.FilterableCurrencyProps, config?: FindConfig<ServiceTypes.CurrencyDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
-    private buildQueryForList;
-    create(data: ServiceTypes.CreateCurrencyDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    update(data: ServiceTypes.UpdateCurrencyDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    delete(ids: string[], sharedContext?: Context): Promise<void>;
+declare const CurrencyService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
+    create: ServiceTypes.CreateCurrencyDTO;
+    update: ServiceTypes.UpdateCurrencyDTO;
+}, {
+    list?: any;
+    listAndCount?: any;
+}>;
+export default class CurrencyService<TEntity extends Currency = Currency> extends CurrencyService_base<TEntity> {
+    constructor(container: InjectedDependencies);
 }
 export {};

package/dist/services/currency.js

@@ -1,97 +1,11 @@
 "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 utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-const _types_1 = require("../types");
-class CurrencyService {
-    constructor({ currencyRepository }) {
-        this.currencyRepository_ = currencyRepository;
-    }
-    async retrieve(currencyCode, config = {}, sharedContext = {}) {
-        return (await (0, utils_1.retrieveEntity)({
-            id: currencyCode,
-            identifierColumn: "code",
-            entityName: _models_1.Currency.name,
-            repository: this.currencyRepository_,
-            config,
-            sharedContext,
-        }));
-    }
-    async list(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.currencyRepository_.find(this.buildQueryForList(filters, config), sharedContext));
-    }
-    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
-        return (await this.currencyRepository_.findAndCount(this.buildQueryForList(filters, config), sharedContext));
-    }
-    buildQueryForList(filters = {}, config = {}) {
-        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
-        if (filters.code) {
-            queryOptions.where["code"] = { $in: filters.code };
-        }
-        return queryOptions;
-    }
-    async create(data, sharedContext = {}) {
-        return (await this.currencyRepository_.create(data, sharedContext));
-    }
-    async update(data, sharedContext = {}) {
-        return (await this.currencyRepository_.update(data, sharedContext));
-    }
-    async delete(ids, sharedContext = {}) {
-        await this.currencyRepository_.delete(ids, sharedContext);
+class CurrencyService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.Currency) {
+    constructor(container) {
+        // @ts-ignore
+        super(...arguments);
     }
 }
 exports.default = CurrencyService;
-__decorate([
-    (0, utils_1.InjectManager)("currencyRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "retrieve", null);
-__decorate([
-    (0, utils_1.InjectManager)("currencyRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "list", null);
-__decorate([
-    (0, utils_1.InjectManager)("currencyRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "listAndCount", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("currencyRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "create", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("currencyRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "update", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("currencyRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], CurrencyService.prototype, "delete", null);

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

@@ -1,19 +1,18 @@
-import { Context, DAL, FindConfig } from "@medusajs/types";
+import { DAL } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
 import { MoneyAmount } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     moneyAmountRepository: DAL.RepositoryService;
 };
-export default class MoneyAmountService<TEntity extends MoneyAmount = MoneyAmount> {
-    protected readonly moneyAmountRepository_: DAL.RepositoryService;
-    constructor({ moneyAmountRepository }: InjectedDependencies);
-    retrieve(moneyAmountId: string, config?: FindConfig<ServiceTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<TEntity>;
-    list(filters?: ServiceTypes.FilterableMoneyAmountProps, config?: FindConfig<ServiceTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<TEntity[]>;
-    listAndCount(filters?: ServiceTypes.FilterableMoneyAmountProps, config?: FindConfig<ServiceTypes.MoneyAmountDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
-    create(data: ServiceTypes.CreateMoneyAmountDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    update(data: ServiceTypes.UpdateMoneyAmountDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    delete(ids: string[], sharedContext?: Context): Promise<void>;
-    softDelete(ids: string[], sharedContext?: Context): Promise<void>;
-    restore(ids: string[], sharedContext?: Context): Promise<[TEntity[], Record<string, unknown[]>]>;
+declare const MoneyAmountService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
+    create: ServiceTypes.CreateMoneyAmountDTO;
+    update: ServiceTypes.UpdateMoneyAmountDTO;
+}, {
+    list: ServiceTypes.FilterableMoneyAmountProps;
+    listAndCount: ServiceTypes.FilterableMoneyAmountProps;
+}>;
+export default class MoneyAmountService<TEntity extends MoneyAmount = MoneyAmount> extends MoneyAmountService_base<TEntity> {
+    constructor(container: InjectedDependencies);
 }
 export {};

package/dist/services/money-amount.js

@@ -1,111 +1,11 @@
 "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 utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
-const _types_1 = require("../types");
-class MoneyAmountService {
-    constructor({ moneyAmountRepository }) {
-        this.moneyAmountRepository_ = moneyAmountRepository;
-    }
-    async retrieve(moneyAmountId, config = {}, sharedContext = {}) {
-        return (await (0, utils_1.retrieveEntity)({
-            id: moneyAmountId,
-            entityName: _models_1.MoneyAmount.name,
-            repository: this.moneyAmountRepository_,
-            config,
-            sharedContext,
-        }));
-    }
-    async list(filters = {}, config = {}, sharedContext = {}) {
-        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
-        return (await this.moneyAmountRepository_.find(queryOptions, sharedContext));
-    }
-    async listAndCount(filters = {}, config = {}, sharedContext = {}) {
-        const queryOptions = utils_1.ModulesSdkUtils.buildQuery(filters, config);
-        return (await this.moneyAmountRepository_.findAndCount(queryOptions, sharedContext));
-    }
-    async create(data, sharedContext = {}) {
-        return (await this.moneyAmountRepository_.create(data, sharedContext));
-    }
-    async update(data, sharedContext = {}) {
-        return (await this.moneyAmountRepository_.update(data, sharedContext));
-    }
-    async delete(ids, sharedContext = {}) {
-        await this.moneyAmountRepository_.delete(ids, sharedContext);
-    }
-    async softDelete(ids, sharedContext = {}) {
-        await this.moneyAmountRepository_.softDelete(ids, sharedContext);
-    }
-    async restore(ids, sharedContext = {}) {
-        return await this.moneyAmountRepository_.restore(ids, sharedContext);
+class MoneyAmountService extends utils_1.ModulesSdkUtils.abstractServiceFactory(_models_1.MoneyAmount) {
+    constructor(container) {
+        // @ts-ignore
+        super(...arguments);
     }
 }
 exports.default = MoneyAmountService;
-__decorate([
-    (0, utils_1.InjectManager)("moneyAmountRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "retrieve", null);
-__decorate([
-    (0, utils_1.InjectManager)("moneyAmountRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "list", null);
-__decorate([
-    (0, utils_1.InjectManager)("moneyAmountRepository_"),
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "listAndCount", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("moneyAmountRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "create", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("moneyAmountRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "update", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("moneyAmountRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "delete", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("moneyAmountRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "softDelete", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("moneyAmountRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Object]),
-    __metadata("design:returntype", Promise)
-], MoneyAmountService.prototype, "restore", null);

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

@@ -1,17 +1,18 @@
-import { Context, DAL, FindConfig } from "@medusajs/types";
+import { Context, DAL } from "@medusajs/types";
+import { ModulesSdkUtils } from "@medusajs/utils";
 import { PriceListRuleValue } from "../models";
 import { ServiceTypes } from "../types";
 type InjectedDependencies = {
     priceListRuleValueRepository: DAL.RepositoryService;
 };
-export default class PriceListRuleValueService<TEntity extends PriceListRuleValue = PriceListRuleValue> {
-    protected readonly priceListRuleValueRepository_: DAL.RepositoryService;
-    constructor({ priceListRuleValueRepository }: InjectedDependencies);
-    retrieve(priceSetId: string, config?: FindConfig<ServiceTypes.PriceListRuleValueDTO>, sharedContext?: Context): Promise<TEntity>;
-    list(filters?: ServiceTypes.FilterablePriceListRuleValueProps, config?: FindConfig<ServiceTypes.PriceListRuleValueDTO>, sharedContext?: Context): Promise<TEntity[]>;
-    listAndCount(filters?: ServiceTypes.FilterablePriceListRuleValueProps, config?: FindConfig<ServiceTypes.PriceListRuleValueDTO>, sharedContext?: Context): Promise<[TEntity[], number]>;
-    create(data: ServiceTypes.CreatePriceListRuleValueDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    update(data: ServiceTypes.UpdatePriceListRuleValueDTO[], sharedContext?: Context): Promise<TEntity[]>;
-    delete(ids: string[], sharedContext?: Context): Promise<void>;
+declare const PriceListRuleValueService_base: new <TEntity_1 extends object = any>(container: InjectedDependencies) => ModulesSdkUtils.AbstractService<TEntity_1, InjectedDependencies, {
+    update: ServiceTypes.UpdatePriceListRuleValueDTO;
+}, {
+    list: ServiceTypes.FilterablePriceListRuleValueProps;
+    listAndCount: ServiceTypes.FilterablePriceListRuleValueProps;
+}>;
+export default class PriceListRuleValueService<TEntity extends PriceListRuleValue = PriceListRuleValue> extends PriceListRuleValueService_base<TEntity> {
+    constructor(container: InjectedDependencies);
+    create(data: ServiceTypes.CreatePriceListRuleValueDTO[], context?: Context): Promise<TEntity[]>;
 }
 export {};