@medusajs/order 0.1.0

package/dist/services/order-module-service.js

@@ -0,0 +1,671 @@
+"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 joiner_config_1 = require("../joiner-config");
+const generateMethodForModels = [
+    _models_1.Address,
+    _models_1.LineItem,
+    _models_1.LineItemAdjustment,
+    _models_1.LineItemTaxLine,
+    _models_1.ShippingMethod,
+    _models_1.ShippingMethodAdjustment,
+    _models_1.ShippingMethodTaxLine,
+];
+class OrderModuleService extends utils_1.ModulesSdkUtils.abstractModuleServiceFactory(_models_1.Order, generateMethodForModels, joiner_config_1.entityNameToLinkableKeysMap) {
+    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, }, moduleDeclaration) {
+        // @ts-ignore
+        super(...arguments);
+        this.moduleDeclaration = moduleDeclaration;
+        this.baseRepository_ = baseRepository;
+        this.orderService_ = orderService;
+        this.addressService_ = addressService;
+        this.lineItemService_ = lineItemService;
+        this.shippingMethodAdjustmentService_ = shippingMethodAdjustmentService;
+        this.shippingMethodService_ = shippingMethodService;
+        this.lineItemAdjustmentService_ = lineItemAdjustmentService;
+        this.shippingMethodTaxLineService_ = shippingMethodTaxLineService;
+        this.lineItemTaxLineService_ = lineItemTaxLineService;
+    }
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
+    }
+    async create(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const orders = await this.create_(input, sharedContext);
+        const result = await this.list({ id: orders.map((p) => p.id) }, {
+            relations: ["shipping_address", "billing_address"],
+        }, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async create_(data, sharedContext = {}) {
+        const lineItemsToCreate = [];
+        const createdOrders = [];
+        for (const { items, ...order } of data) {
+            const [created] = await this.orderService_.create([order], sharedContext);
+            createdOrders.push(created);
+            if (items?.length) {
+                const orderItems = items.map((item) => {
+                    return {
+                        ...item,
+                        order_id: created.id,
+                    };
+                });
+                lineItemsToCreate.push(...orderItems);
+            }
+        }
+        if (lineItemsToCreate.length) {
+            await this.addLineItemsBulk_(lineItemsToCreate, sharedContext);
+        }
+        return createdOrders;
+    }
+    async update(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const orders = await this.update_(input, sharedContext);
+        const result = await this.list({ id: orders.map((p) => p.id) }, {
+            relations: ["shipping_address", "billing_address"],
+        }, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async update_(data, sharedContext = {}) {
+        return await this.orderService_.update(data, sharedContext);
+    }
+    async addLineItems(orderIdOrData, data, sharedContext = {}) {
+        let items = [];
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            items = await this.addLineItems_(orderIdOrData, data, sharedContext);
+        }
+        else {
+            const data = Array.isArray(orderIdOrData)
+                ? orderIdOrData
+                : [orderIdOrData];
+            items = await this.addLineItemsBulk_(data, sharedContext);
+        }
+        return await this.baseRepository_.serialize(items, {
+            populate: true,
+        });
+    }
+    async addLineItems_(orderId, items, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"] }, sharedContext);
+        const toUpdate = items.map((item) => {
+            return {
+                ...item,
+                order_id: order.id,
+            };
+        });
+        return await this.addLineItemsBulk_(toUpdate, sharedContext);
+    }
+    async addLineItemsBulk_(data, sharedContext = {}) {
+        return await this.lineItemService_.create(data, sharedContext);
+    }
+    async updateLineItems(lineItemIdOrDataOrSelector, data, sharedContext = {}) {
+        let items = [];
+        if ((0, utils_1.isString)(lineItemIdOrDataOrSelector)) {
+            const item = await this.updateLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
+            return await this.baseRepository_.serialize(item, {
+                populate: true,
+            });
+        }
+        const toUpdate = Array.isArray(lineItemIdOrDataOrSelector)
+            ? lineItemIdOrDataOrSelector
+            : [
+                {
+                    selector: lineItemIdOrDataOrSelector,
+                    data: data,
+                },
+            ];
+        items = await this.updateLineItemsWithSelector_(toUpdate, sharedContext);
+        return await this.baseRepository_.serialize(items, {
+            populate: true,
+        });
+    }
+    async updateLineItem_(lineItemId, data, sharedContext = {}) {
+        const [item] = await this.lineItemService_.update([{ id: lineItemId, ...data }], sharedContext);
+        return item;
+    }
+    async updateLineItemsWithSelector_(updates, sharedContext = {}) {
+        let toUpdate = [];
+        for (const { selector, data } of updates) {
+            const items = await this.listLineItems({ ...selector }, {}, sharedContext);
+            items.forEach((item) => {
+                toUpdate.push({
+                    ...data,
+                    id: item.id,
+                });
+            });
+        }
+        return await this.lineItemService_.update(toUpdate, sharedContext);
+    }
+    async removeLineItems(itemIdsOrSelector, sharedContext = {}) {
+        let toDelete;
+        if ((0, utils_1.isObject)(itemIdsOrSelector)) {
+            const items = await this.listLineItems({ ...itemIdsOrSelector }, {}, sharedContext);
+            toDelete = items.map((item) => item.id);
+        }
+        else {
+            toDelete = Array.isArray(itemIdsOrSelector)
+                ? itemIdsOrSelector
+                : [itemIdsOrSelector];
+        }
+        await this.lineItemService_.delete(toDelete, sharedContext);
+    }
+    async createAddresses(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const addresses = await this.createAddresses_(input, sharedContext);
+        const result = await this.listAddresses({ id: addresses.map((p) => p.id) }, {}, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async createAddresses_(data, sharedContext = {}) {
+        return await this.addressService_.create(data, sharedContext);
+    }
+    async updateAddresses(data, sharedContext = {}) {
+        const input = Array.isArray(data) ? data : [data];
+        const addresses = await this.updateAddresses_(input, sharedContext);
+        const result = await this.listAddresses({ id: addresses.map((p) => p.id) }, {}, sharedContext);
+        return (Array.isArray(data) ? result : result[0]);
+    }
+    async updateAddresses_(data, sharedContext = {}) {
+        return await this.addressService_.update(data, sharedContext);
+    }
+    async addShippingMethods(orderIdOrData, data, sharedContext = {}) {
+        let methods;
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            methods = await this.addShippingMethods_(orderIdOrData, data, sharedContext);
+        }
+        else {
+            const data = Array.isArray(orderIdOrData)
+                ? orderIdOrData
+                : [orderIdOrData];
+            methods = await this.addShippingMethodsBulk_(data, sharedContext);
+        }
+        return await this.baseRepository_.serialize(methods, { populate: true });
+    }
+    async addShippingMethods_(orderId, data, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"] }, sharedContext);
+        const methods = data.map((method) => {
+            return {
+                ...method,
+                order_id: order.id,
+            };
+        });
+        return await this.addShippingMethodsBulk_(methods, sharedContext);
+    }
+    async addShippingMethodsBulk_(data, sharedContext = {}) {
+        return await this.shippingMethodService_.create(data, sharedContext);
+    }
+    async removeShippingMethods(methodIdsOrSelector, sharedContext = {}) {
+        let toDelete;
+        if ((0, utils_1.isObject)(methodIdsOrSelector)) {
+            const methods = await this.listShippingMethods({
+                ...methodIdsOrSelector,
+            }, {}, sharedContext);
+            toDelete = methods.map((m) => m.id);
+        }
+        else {
+            toDelete = Array.isArray(methodIdsOrSelector)
+                ? methodIdsOrSelector
+                : [methodIdsOrSelector];
+        }
+        await this.shippingMethodService_.delete(toDelete, sharedContext);
+    }
+    async addLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+        let addedAdjustments = [];
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["items"] }, sharedContext);
+            const lineIds = order.items?.map((item) => item.id);
+            for (const adj of adjustments || []) {
+                if (!lineIds?.includes(adj.item_id)) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Line item with id ${adj.item_id} does not exist on order with id ${orderIdOrData}`);
+                }
+            }
+            addedAdjustments = await this.lineItemAdjustmentService_.create(adjustments, sharedContext);
+        }
+        else {
+            const data = Array.isArray(orderIdOrData)
+                ? orderIdOrData
+                : [orderIdOrData];
+            addedAdjustments = await this.lineItemAdjustmentService_.create(data, sharedContext);
+        }
+        return await this.baseRepository_.serialize(addedAdjustments, {
+            populate: true,
+        });
+    }
+    async setLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.adjustments"] }, sharedContext);
+        const existingAdjustments = await this.listLineItemAdjustments({ item: { order_id: order.id } }, { select: ["id"] }, sharedContext);
+        const adjustmentsSet = new Set(adjustments
+            .map((a) => a.id)
+            .filter(Boolean));
+        const toDelete = [];
+        // From the existing adjustments, find the ones that are not passed in adjustments
+        existingAdjustments.forEach((adj) => {
+            if (!adjustmentsSet.has(adj.id)) {
+                toDelete.push(adj);
+            }
+        });
+        if (toDelete.length) {
+            await this.lineItemAdjustmentService_.delete(toDelete.map((adj) => adj.id), sharedContext);
+        }
+        let result = await this.lineItemAdjustmentService_.upsert(adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result, {
+            populate: true,
+        });
+    }
+    async removeLineItemAdjustments(adjustmentIdsOrSelector, sharedContext = {}) {
+        let ids;
+        if ((0, utils_1.isObject)(adjustmentIdsOrSelector)) {
+            const adjustments = await this.listLineItemAdjustments({
+                ...adjustmentIdsOrSelector,
+            }, { select: ["id"] }, sharedContext);
+            ids = adjustments.map((adj) => adj.id);
+        }
+        else {
+            ids = Array.isArray(adjustmentIdsOrSelector)
+                ? adjustmentIdsOrSelector
+                : [adjustmentIdsOrSelector];
+        }
+        await this.lineItemAdjustmentService_.delete(ids, sharedContext);
+    }
+    async setShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
+        const existingAdjustments = await this.listShippingMethodAdjustments({ shipping_method: { order_id: order.id } }, { select: ["id"] }, sharedContext);
+        const adjustmentsSet = new Set(adjustments
+            .map((a) => a?.id)
+            .filter(Boolean));
+        const toDelete = [];
+        // From the existing adjustments, find the ones that are not passed in adjustments
+        existingAdjustments.forEach((adj) => {
+            if (!adjustmentsSet.has(adj.id)) {
+                toDelete.push(adj);
+            }
+        });
+        if (toDelete.length) {
+            await this.shippingMethodAdjustmentService_.delete(toDelete.map((adj) => adj.id), sharedContext);
+        }
+        const result = await this.shippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
+        return await this.baseRepository_.serialize(result, {
+            populate: true,
+        });
+    }
+    async addShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+        let addedAdjustments = [];
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
+            const methodIds = order.shipping_methods?.map((method) => method.id);
+            for (const adj of adjustments || []) {
+                if (!methodIds?.includes(adj.shipping_method_id)) {
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Shipping method with id ${adj.shipping_method_id} does not exist on order with id ${orderIdOrData}`);
+                }
+            }
+            addedAdjustments = await this.shippingMethodAdjustmentService_.create(adjustments, sharedContext);
+        }
+        else {
+            const data = Array.isArray(orderIdOrData)
+                ? orderIdOrData
+                : [orderIdOrData];
+            addedAdjustments = await this.shippingMethodAdjustmentService_.create(data, sharedContext);
+        }
+        if ((0, utils_1.isObject)(orderIdOrData)) {
+            return await this.baseRepository_.serialize(addedAdjustments[0], {
+                populate: true,
+            });
+        }
+        return await this.baseRepository_.serialize(addedAdjustments, {
+            populate: true,
+        });
+    }
+    async removeShippingMethodAdjustments(adjustmentIdsOrSelector, sharedContext = {}) {
+        let ids;
+        if ((0, utils_1.isObject)(adjustmentIdsOrSelector)) {
+            const adjustments = await this.listShippingMethodAdjustments({
+                ...adjustmentIdsOrSelector,
+            }, { select: ["id"] }, sharedContext);
+            ids = adjustments.map((adj) => adj.id);
+        }
+        else {
+            ids = Array.isArray(adjustmentIdsOrSelector)
+                ? adjustmentIdsOrSelector
+                : [adjustmentIdsOrSelector];
+        }
+        await this.shippingMethodAdjustmentService_.delete(ids, sharedContext);
+    }
+    async addLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+        let addedTaxLines;
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            // existence check
+            await this.retrieve(orderIdOrData, { select: ["id"] }, sharedContext);
+            const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
+            addedTaxLines = await this.lineItemTaxLineService_.create(lines, sharedContext);
+        }
+        else {
+            const data = Array.isArray(orderIdOrData)
+                ? orderIdOrData
+                : [orderIdOrData];
+            addedTaxLines = await this.lineItemTaxLineService_.create(data, sharedContext);
+        }
+        const serialized = await this.baseRepository_.serialize(addedTaxLines, {
+            populate: true,
+        });
+        if ((0, utils_1.isObject)(orderIdOrData)) {
+            return serialized[0];
+        }
+        return serialized;
+    }
+    async setLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.tax_lines"] }, sharedContext);
+        const existingTaxLines = await this.listLineItemTaxLines({ item: { order_id: order.id } }, { select: ["id"] }, sharedContext);
+        const taxLinesSet = new Set(taxLines
+            .map((taxLine) => taxLine?.id)
+            .filter(Boolean));
+        const toDelete = [];
+        // From the existing tax lines, find the ones that are not passed in taxLines
+        existingTaxLines.forEach((taxLine) => {
+            if (!taxLinesSet.has(taxLine.id)) {
+                toDelete.push(taxLine);
+            }
+        });
+        if (toDelete.length) {
+            await this.lineItemTaxLineService_.delete(toDelete.map((taxLine) => taxLine.id), sharedContext);
+        }
+        const result = await this.lineItemTaxLineService_.upsert(taxLines, sharedContext);
+        return await this.baseRepository_.serialize(result, {
+            populate: true,
+        });
+    }
+    async removeLineItemTaxLines(taxLineIdsOrSelector, sharedContext = {}) {
+        let ids;
+        if ((0, utils_1.isObject)(taxLineIdsOrSelector)) {
+            const taxLines = await this.listLineItemTaxLines({
+                ...taxLineIdsOrSelector,
+            }, { select: ["id"] }, sharedContext);
+            ids = taxLines.map((taxLine) => taxLine.id);
+        }
+        else {
+            ids = Array.isArray(taxLineIdsOrSelector)
+                ? taxLineIdsOrSelector
+                : [taxLineIdsOrSelector];
+        }
+        await this.lineItemTaxLineService_.delete(ids, sharedContext);
+    }
+    async addShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+        let addedTaxLines;
+        if ((0, utils_1.isString)(orderIdOrData)) {
+            // existence check
+            await this.retrieve(orderIdOrData, { select: ["id"] }, sharedContext);
+            const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
+            addedTaxLines = await this.shippingMethodTaxLineService_.create(lines, sharedContext);
+        }
+        else {
+            addedTaxLines = await this.shippingMethodTaxLineService_.create(taxLines, sharedContext);
+        }
+        const serialized = await this.baseRepository_.serialize(addedTaxLines[0], {
+            populate: true,
+        });
+        if ((0, utils_1.isObject)(orderIdOrData)) {
+            return serialized[0];
+        }
+        return serialized;
+    }
+    async setShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
+        const existingTaxLines = await this.listShippingMethodTaxLines({ shipping_method: { order_id: order.id } }, { select: ["id"] }, sharedContext);
+        const taxLinesSet = new Set(taxLines
+            .map((taxLine) => taxLine?.id)
+            .filter(Boolean));
+        const toDelete = [];
+        // From the existing tax lines, find the ones that are not passed in taxLines
+        existingTaxLines.forEach((taxLine) => {
+            if (!taxLinesSet.has(taxLine.id)) {
+                toDelete.push(taxLine);
+            }
+        });
+        if (toDelete.length) {
+            await this.shippingMethodTaxLineService_.delete(toDelete.map((taxLine) => taxLine.id), sharedContext);
+        }
+        const result = await this.shippingMethodTaxLineService_.upsert(taxLines, sharedContext);
+        return await this.baseRepository_.serialize(result, {
+            populate: true,
+        });
+    }
+    async removeShippingMethodTaxLines(taxLineIdsOrSelector, sharedContext = {}) {
+        let ids;
+        if ((0, utils_1.isObject)(taxLineIdsOrSelector)) {
+            const taxLines = await this.listShippingMethodTaxLines({
+                ...taxLineIdsOrSelector,
+            }, { select: ["id"] }, sharedContext);
+            ids = taxLines.map((taxLine) => taxLine.id);
+        }
+        else {
+            ids = Array.isArray(taxLineIdsOrSelector)
+                ? taxLineIdsOrSelector
+                : [taxLineIdsOrSelector];
+        }
+        await this.shippingMethodTaxLineService_.delete(ids, sharedContext);
+    }
+}
+exports.default = OrderModuleService;
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "create", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "create_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "update", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "update_", 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)
+], OrderModuleService.prototype, "addLineItems", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addLineItems_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addLineItemsBulk_", 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)
+], OrderModuleService.prototype, "updateLineItems", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateLineItem_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateLineItemsWithSelector_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeLineItems", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createAddresses", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "createAddresses_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateAddresses", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "updateAddresses_", null);
+__decorate([
+    (0, utils_1.InjectManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addShippingMethods", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addShippingMethods_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addShippingMethodsBulk_", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeShippingMethods", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addLineItemAdjustments", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "setLineItemAdjustments", null);
+__decorate([
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeLineItemAdjustments", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "setShippingMethodAdjustments", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addShippingMethodAdjustments", null);
+__decorate([
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeShippingMethodAdjustments", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addLineItemTaxLines", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "setLineItemTaxLines", null);
+__decorate([
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeLineItemTaxLines", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "addShippingMethodTaxLines", null);
+__decorate([
+    (0, utils_1.InjectTransactionManager)("baseRepository_"),
+    __param(2, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Array, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "setShippingMethodTaxLines", null);
+__decorate([
+    __param(1, (0, utils_1.MedusaContext)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], OrderModuleService.prototype, "removeShippingMethodTaxLines", null);

package/dist/types/UpdateOrderShippingMethodDTO.d.ts

@@ -0,0 +1,7 @@
+import { BigNumberInput } from "@medusajs/types";
+export interface UpdateOrderShippingMethodDTO {
+    id: string;
+    name?: string;
+    amount?: BigNumberInput;
+    data?: Record<string, unknown>;
+}

package/dist/types/UpdateOrderShippingMethodDTO.js

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