@medusajs/order 0.1.3-snapshot-20240718073308 → 0.1.3

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

@@ -1,33 +1,10 @@
 "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 __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 __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 __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
@@ -38,32 +15,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const types_1 = require("@medusajs/types");
 const utils_1 = require("@medusajs/utils");
 const _models_1 = require("../models");
+const joiner_config_1 = require("../joiner-config");
 const utils_2 = require("../utils");
-const BundledActions = __importStar(require("./actions"));
-const generateMethodForModels = {
-    Order: _models_1.Order,
-    Address: _models_1.Address,
-    LineItem: _models_1.LineItem,
-    LineItemAdjustment: _models_1.LineItemAdjustment,
-    LineItemTaxLine: _models_1.LineItemTaxLine,
-    ShippingMethod: _models_1.ShippingMethod,
-    ShippingMethodAdjustment: _models_1.ShippingMethodAdjustment,
-    ShippingMethodTaxLine: _models_1.ShippingMethodTaxLine,
-    Transaction: _models_1.Transaction,
-    OrderChange: _models_1.OrderChange,
-    OrderChangeAction: _models_1.OrderChangeAction,
-    OrderItem: _models_1.OrderItem,
-    OrderSummary: _models_1.OrderSummary,
-    OrderShippingMethod: _models_1.OrderShippingMethod,
-    ReturnReason: _models_1.ReturnReason,
-    Return: _models_1.Return,
-    ReturnItem: _models_1.ReturnItem,
-    OrderClaim: _models_1.OrderClaim,
-    OrderExchange: _models_1.OrderExchange,
-};
-// TODO: rm template args here, keep it for later to not collide with carlos work at least as little as possible
-class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateMethodForModels) {
-    constructor({ baseRepository, orderService, addressService, lineItemService, shippingMethodAdjustmentService, shippingMethodService, lineItemAdjustmentService, shippingMethodTaxLineService, lineItemTaxLineService, transactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingMethodService, returnReasonService, returnService, returnItemService, orderClaimService, orderExchangeService, }, moduleDeclaration) {
+const transform_order_1 = require("../utils/transform-order");
+const generateMethodForModels = [
+    _models_1.Address,
+    _models_1.LineItem,
+    _models_1.LineItemAdjustment,
+    _models_1.LineItemTaxLine,
+    _models_1.ShippingMethod,
+    _models_1.ShippingMethodAdjustment,
+    _models_1.ShippingMethodTaxLine,
+    _models_1.Transaction,
+    _models_1.OrderChange,
+    _models_1.OrderChangeAction,
+    _models_1.OrderItem,
+    _models_1.OrderSummary,
+    _models_1.OrderShippingMethod,
+];
+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, transactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingMethodService, }, moduleDeclaration) {
         // @ts-ignore
         super(...arguments);
         this.moduleDeclaration = moduleDeclaration;
@@ -82,11 +53,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         this.orderItemService_ = orderItemService;
         this.orderSummaryService_ = orderSummaryService;
         this.orderShippingMethodService_ = orderShippingMethodService;
-        this.returnReasonService_ = returnReasonService;
-        this.returnService_ = returnService;
-        this.returnItemService_ = returnItemService;
-        this.orderClaimService_ = orderClaimService;
-        this.orderExchangeService_ = orderExchangeService;
+    }
+    __joinerConfig() {
+        return joiner_config_1.joinerConfig;
     }
     shouldIncludeTotals(config) {
         const totalFields = [
@@ -117,8 +86,8 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return includeTotals;
     }
     addRelationsToCalculateTotals(config, totalFields) {
-        config.relations ??= [];
-        config.select ??= [];
+        config.relations ?? (config.relations = []);
+        config.select ?? (config.select = []);
         const requiredFieldsForTotals = [
             "items",
             "items.tax_lines",
@@ -135,144 +104,33 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             return (!requiredFieldsForTotals.some((val) => val.startsWith(field)) && !totalFields.includes(field));
         });
     }
-    // @ts-expect-error
-    async retrieveOrder(id, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const order = await super.retrieveOrder(id, config, sharedContext);
-        const orderChange = await this.getActiveOrderChange_(order.id, false, sharedContext);
-        order.order_change = orderChange;
-        return (0, utils_2.formatOrder)(order, {
-            entity: _models_1.Order,
-            includeTotals,
-        });
-    }
-    // @ts-expect-error
-    async listOrders(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const orders = await super.listOrders(filters, config, sharedContext);
-        return (0, utils_2.formatOrder)(orders, {
-            entity: _models_1.Order,
-            includeTotals,
-        });
-    }
-    // @ts-expect-error
-    async listAndCountOrders(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const [orders, count] = await super.listAndCountOrders(filters, config, sharedContext);
-        return [
-            (0, utils_2.formatOrder)(orders, {
-                entity: _models_1.Order,
-                includeTotals,
-            }),
-            count,
-        ];
-    }
-    // @ts-ignore
-    async retrieveReturn(id, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrder = await super.retrieveReturn(id, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrder, {
-            entity: _models_1.Return,
-            includeTotals,
-        });
-    }
-    // @ts-ignore
-    async listReturns(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrders = await super.listReturns(filters, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrders, {
-            entity: _models_1.Return,
-            includeTotals,
-        });
-    }
-    // @ts-ignore
-    async listAndCountReturns(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const [returnOrders, count] = await super.listAndCountReturns(filters, config, sharedContext);
-        return [
-            (0, utils_2.formatOrder)(returnOrders, {
-                entity: _models_1.Return,
-                includeTotals,
-            }),
-            count,
-        ];
-    }
-    // @ts-ignore
-    async retrieveOrderClaim(id, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrder = await super.retrieveOrderClaim(id, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrder, {
-            entity: _models_1.OrderClaim,
-            includeTotals,
-        });
-    }
-    // @ts-ignore
-    async listOrderClaims(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrders = await super.listOrderClaims(filters, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrders, {
-            entity: _models_1.OrderClaim,
-            includeTotals,
-        });
-    }
-    // @ts-ignore
-    async listAndCountOrderClaims(filters, config, sharedContext) {
-        config ??= {};
-        const includeTotals = this.shouldIncludeTotals(config);
-        const [returnOrders, count] = await super.listAndCountOrderClaims(filters, config, sharedContext);
-        return [
-            (0, utils_2.formatOrder)(returnOrders, {
-                entity: _models_1.OrderClaim,
-                includeTotals,
-            }),
-            count,
-        ];
-    }
-    // @ts-ignore
-    async retrieveOrderExchange(id, config, sharedContext) {
-        config ??= {};
+    async retrieve(id, config, sharedContext) {
+        config ?? (config = {});
         const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrder = await super.retrieveOrderExchange(id, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrder, {
-            entity: _models_1.OrderExchange,
-            includeTotals,
-        });
+        const order = await super.retrieve(id, config, sharedContext);
+        return (0, transform_order_1.formatOrder)(order, { includeTotals });
     }
-    // @ts-ignore
-    async listOrderExchanges(filters, config, sharedContext) {
-        config ??= {};
+    async list(filters, config, sharedContext) {
+        config ?? (config = {});
         const includeTotals = this.shouldIncludeTotals(config);
-        const returnOrders = await super.listOrderExchanges(filters, config, sharedContext);
-        return (0, utils_2.formatOrder)(returnOrders, {
-            entity: _models_1.OrderExchange,
+        const orders = await super.list(filters, config, sharedContext);
+        return (0, transform_order_1.formatOrder)(orders, {
             includeTotals,
         });
     }
-    // @ts-ignore
-    async listAndCountOrderExchanges(filters, config, sharedContext) {
-        config ??= {};
+    async listAndCount(filters, config, sharedContext) {
+        config ?? (config = {});
         const includeTotals = this.shouldIncludeTotals(config);
-        const [returnOrders, count] = await super.listAndCountOrderExchanges(filters, config, sharedContext);
+        const [orders, count] = await super.listAndCount(filters, config, sharedContext);
         return [
-            (0, utils_2.formatOrder)(returnOrders, {
-                entity: _models_1.OrderExchange,
-                includeTotals,
-            }),
+            (0, transform_order_1.formatOrder)(orders, { includeTotals }),
             count,
         ];
     }
-    async createOrders(data, sharedContext = {}) {
+    async create(data, sharedContext = {}) {
         const input = Array.isArray(data) ? data : [data];
-        const orders = await this.createOrders_(input, sharedContext);
-        const result = await this.listOrders({
+        const orders = await this.create_(input, sharedContext);
+        const result = await this.list({
             id: orders.map((p) => p.id),
         }, {
             relations: [
@@ -290,7 +148,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, sharedContext);
         return (Array.isArray(data) ? result : result[0]);
     }
-    async createOrders_(data, sharedContext = {}) {
+    async create_(data, sharedContext = {}) {
         const lineItemsToCreate = [];
         const createdOrders = [];
         for (const { items, shipping_methods, ...order } of data) {
@@ -331,14 +189,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return createdOrders;
     }
-    async updateOrders(dataOrIdOrSelector, data, sharedContext = {}) {
-        const result = await this.updateOrders_(dataOrIdOrSelector, data, sharedContext);
+    async update(dataOrIdOrSelector, data, sharedContext = {}) {
+        const result = await this.update_(dataOrIdOrSelector, data, sharedContext);
         const serializedResult = await this.baseRepository_.serialize(result, {
             populate: true,
         });
         return (0, utils_1.isString)(dataOrIdOrSelector) ? serializedResult[0] : serializedResult;
     }
-    async updateOrders_(dataOrIdOrSelector, data, sharedContext = {}) {
+    async update_(dataOrIdOrSelector, data, sharedContext = {}) {
         let toUpdate = [];
         if ((0, utils_1.isString)(dataOrIdOrSelector)) {
             toUpdate = [
@@ -373,7 +231,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -391,7 +249,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
     }
     async createLineItems_(orderId, items, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
+        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
         const toUpdate = items.map((item) => {
             return {
                 ...item,
@@ -543,7 +401,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ? orderIdOrData
                 : [orderIdOrData];
             const allOrderIds = data.map((dt) => dt.order_id);
-            const order = await this.listOrders({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
+            const order = await this.list({ id: allOrderIds }, { select: ["id", "version"] }, sharedContext);
             const mapOrderVersion = order.reduce((acc, curr) => {
                 acc[curr.id] = curr.version;
                 return acc;
@@ -552,10 +410,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 return {
                     shipping_method: dt,
                     order_id: dt.order_id,
-                    return_id: dt.return_id,
-                    claim_id: dt.claim_id,
-                    exchange_id: dt.exchange_id,
-                    version: dt.version ?? mapOrderVersion[dt.order_id],
+                    version: mapOrderVersion[dt.order_id],
                 };
             });
             methods = await this.createShippingMethodsBulk_(orderShippingMethodData, sharedContext);
@@ -563,15 +418,12 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return await this.baseRepository_.serialize(methods, { populate: true });
     }
     async createShippingMethods_(orderId, data, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
-        const methods = data.map((methodData) => {
+        const order = await this.retrieve(orderId, { select: ["id", "version"] }, sharedContext);
+        const methods = data.map((method) => {
             return {
-                shipping_method: methodData,
+                shipping_method: method,
                 order_id: order.id,
-                return_id: methodData.return_id,
-                claim_id: methodData.claim_id,
-                exchange_id: methodData.exchange_id,
-                version: methodData.version ?? order.version ?? 1,
+                version: method.version ?? order.version ?? 1,
             };
         });
         return await this.createShippingMethodsBulk_(methods, sharedContext);
@@ -580,38 +432,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         const sm = await this.orderShippingMethodService_.create(data, sharedContext);
         return sm.map((s) => s.shipping_method);
     }
-    // @ts-ignore
-    async softDeleteShippingMethods(ids, config, sharedContext) {
-        const rel = await super.listOrderShippingMethods({
-            shipping_method_id: ids,
-        }, {
-            select: ["id"],
-        }, sharedContext);
-        const orderShippingMethodIds = rel.map((r) => r.id);
-        const [returned] = await (0, utils_1.promiseAll)([
-            super.softDeleteShippingMethods(ids, config, sharedContext),
-            super.softDeleteOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
-        ]);
-        return returned;
-    }
-    // @ts-ignore
-    async restoreShippingMethods(transactionIds, config, sharedContext) {
-        const rel = await super.listOrderShippingMethods({
-            shipping_method_id: transactionIds,
-        }, {
-            select: ["id"],
-        }, sharedContext);
-        const orderShippingMethodIds = rel.map((r) => r.id);
-        const [returned] = await (0, utils_1.promiseAll)([
-            super.restoreShippingMethods(transactionIds, config, sharedContext),
-            super.restoreOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
-        ]);
-        return returned;
-    }
     async createLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
+            const order = await this.retrieve(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
             const lineIds = order.items?.map((item) => item.id);
             for (const adj of adjustments || []) {
                 if (!lineIds?.includes(adj.item_id)) {
@@ -631,7 +455,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
     }
     async setLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
         const existingAdjustments = (order.items ?? [])
             .map((item) => item.adjustments ?? [])
             .flat()
@@ -655,7 +479,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
     }
     async setShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
         const existingAdjustments = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.adjustments ?? [])
             .flat()
@@ -681,7 +505,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     async createShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
+            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)) {
@@ -726,7 +550,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return serialized;
     }
     async setLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.items ?? [])
             .map((item) => item.tax_lines ?? [])
             .flat()
@@ -766,7 +590,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return serialized;
     }
     async setShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
-        const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
+        const order = await this.retrieve(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.tax_lines ?? [])
             .flat()
@@ -788,42 +612,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             populate: true,
         });
     }
-    async createReturns(data, sharedContext) {
-        const created = await this.createOrderRelatedEntity_(data, this.returnService_, sharedContext);
-        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
-            populate: true,
-        });
-    }
-    async createOrderClaims(data, sharedContext) {
-        const created = await this.createOrderRelatedEntity_(data, this.orderClaimService_, sharedContext);
-        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
-            populate: true,
-        });
-    }
-    async createOrderExchanges(data, sharedContext) {
-        const created = await this.createOrderRelatedEntity_(data, this.orderExchangeService_, sharedContext);
-        return await this.baseRepository_.serialize(!Array.isArray(data) ? created[0] : created, {
-            populate: true,
-        });
-    }
-    async createOrderRelatedEntity_(data, service, sharedContext) {
-        const data_ = Array.isArray(data) ? data : [data];
-        const inputDataMap = data_.reduce((acc, curr) => {
-            acc[curr.order_id] = curr;
-            return acc;
-        }, {});
-        const orderIds = data_.map((d) => d.order_id);
-        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
-        if (orders.length !== orderIds.length) {
-            const foundOrders = orders.map((o) => o.id);
-            const missing = orderIds.filter((id) => !foundOrders.includes(id));
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
-        }
-        for (const order of orders) {
-            inputDataMap[order.id].order_version = order.version;
-        }
-        return await service.create(data_, sharedContext);
-    }
     async createOrderChange(data, sharedContext) {
         const changes = await this.createOrderChange_(data, sharedContext);
         return await this.baseRepository_.serialize(Array.isArray(data) ? changes : changes[0], {
@@ -834,26 +622,21 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         const dataArr = Array.isArray(data) ? data : [data];
         const orderIds = [];
         const dataMap = {};
-        const orderChanges = await this.listOrderChanges({
-            order_id: dataArr.map((data) => data.order_id),
-            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
-        }, {}, sharedContext);
-        const orderChangesMap = new Map(orderChanges.map((item) => [item.order_id, item]));
         for (const change of dataArr) {
             orderIds.push(change.order_id);
             dataMap[change.order_id] = change;
         }
-        const orders = await this.orderService_.list({ id: orderIds }, { select: ["id", "version"] }, sharedContext);
+        const orders = await this.list({
+            id: orderIds,
+        }, {
+            select: ["id", "version"],
+        }, sharedContext);
         if (orders.length !== orderIds.length) {
             const foundOrders = orders.map((o) => o.id);
             const missing = orderIds.filter((id) => !foundOrders.includes(id));
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order could not be found: ${missing.join(", ")}`);
         }
         const input = orders.map((order) => {
-            const existingOrderChange = orderChangesMap.get(order.id);
-            if (existingOrderChange) {
-                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order (${order.id}) already has an existing active order change`);
-            }
             return {
                 ...dataMap[order.id],
                 version: order.version + 1,
@@ -861,98 +644,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         return await this.orderChangeService_.create(input, sharedContext);
     }
-    async previewOrderChange(orderId, sharedContext) {
-        const order = await this.retrieveOrder(orderId, {
-            select: ["id", "version", "items.detail", "summary", "total"],
-            relations: [
-                "transactions",
-                "items",
-                "items.detail",
-                "shipping_methods",
-            ],
-        }, sharedContext);
-        if (!order.order_change) {
-            return order;
-        }
-        const orderChange = await super.retrieveOrderChange(order.order_change.id, { relations: ["actions"] }, sharedContext);
-        orderChange.actions = orderChange.actions.map((action) => {
-            return {
-                ...action,
-                version: orderChange.version,
-                order_id: orderChange.order_id,
-                return_id: orderChange.return_id,
-                claim_id: orderChange.claim_id,
-                exchange_id: orderChange.exchange_id,
-            };
-        });
-        const { itemsToUpsert, shippingMethodsToUpsert, calculatedOrders } = (0, utils_2.applyChangesToOrder)([order], { [order.id]: orderChange.actions }, { addActionReferenceToObject: true });
-        const calculated = calculatedOrders[order.id];
-        const addedItems = {};
-        const addedShippingMethods = {};
-        for (const item of calculated.order.items) {
-            const isExistingItem = item.id === item.detail?.item_id;
-            if (!isExistingItem) {
-                addedItems[item.id] = item;
-            }
-        }
-        for (const sm of calculated.order.shipping_methods) {
-            if (!(0, utils_1.isDefined)(sm.shipping_option_id)) {
-                addedShippingMethods[sm.id] = sm;
-            }
-        }
-        if (Object.keys(addedItems).length > 0) {
-            const addedItemDetails = await this.listLineItems({ id: Object.keys(addedItems) }, {
-                relations: ["adjustments", "tax_lines"],
-            }, sharedContext);
-            calculated.order.items.forEach((item, idx) => {
-                if (!addedItems[item.id]) {
-                    return;
-                }
-                const lineItem = addedItemDetails.find((d) => d.id === item.id);
-                const actions = item.actions;
-                delete item.actions;
-                const newItem = itemsToUpsert.find((d) => d.item_id === item.id);
-                calculated.order.items[idx] = {
-                    ...lineItem,
-                    actions,
-                    quantity: newItem.quantity,
-                    detail: {
-                        ...newItem,
-                        ...item,
-                    },
-                };
-            });
-        }
-        if (Object.keys(addedShippingMethods).length > 0) {
-            const addedShippingDetails = await this.listShippingMethods({ id: Object.keys(addedShippingMethods) }, {
-                relations: ["adjustments", "tax_lines"],
-            }, sharedContext);
-            calculated.order.shipping_methods.forEach((sm, idx) => {
-                if (!addedShippingMethods[sm.id]) {
-                    return;
-                }
-                const shippingMethod = addedShippingDetails.find((d) => d.id === sm.id);
-                const actions = sm.actions;
-                delete sm.actions;
-                const newItem = shippingMethodsToUpsert.find((d) => d.id === sm.id);
-                sm.shipping_method_id = sm.id;
-                delete sm.id;
-                calculated.order.shipping_methods[idx] = {
-                    ...shippingMethod,
-                    actions,
-                    detail: {
-                        ...sm,
-                        ...newItem,
-                    },
-                };
-            });
-        }
-        const calcOrder = calculated.order;
-        (0, utils_1.decorateCartTotals)(calcOrder);
-        calcOrder.summary = calculated.summary;
-        (0, utils_1.createRawPropertiesFromBigNumber)(calcOrder);
-        return calcOrder;
-    }
     async cancelOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
             ? orderChangeIdOrData
@@ -992,14 +683,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     ...action,
                     version: change.version,
                     order_id: change.order_id,
-                    return_id: change.return_id,
-                    claim_id: change.claim_id,
-                    exchange_id: change.exchange_id,
                 };
             });
             return change.actions;
         });
-        return await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
+        await this.applyOrderChanges_(orderChanges.flat(), sharedContext);
     }
     async declineOrderChange(orderChangeIdOrData, sharedContext) {
         const data = Array.isArray(orderChangeIdOrData)
@@ -1020,7 +708,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
     }
     async applyPendingOrderActions(orderId, sharedContext) {
         const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.orderService_.list({ id: orderIds }, {
+        const orders = await this.list({ id: orderIds }, {
             select: ["id", "version"],
         }, sharedContext);
         const changes = await this.orderChangeActionService_.list({
@@ -1031,9 +719,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             select: [
                 "id",
                 "order_id",
-                "return_id",
-                "exchange_id",
-                "claim_id",
                 "ordering",
                 "version",
                 "applied",
@@ -1049,10 +734,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ordering: "ASC",
             },
         }, sharedContext);
-        return await this.applyOrderChanges_(changes, sharedContext);
+        await this.applyOrderChanges_(changes, sharedContext);
     }
     async revertLastVersion(orderId, sharedContext) {
-        const order = await super.retrieveOrder(orderId, {
+        const order = await super.retrieve(orderId, {
             select: ["id", "version"],
         }, sharedContext);
         if (order.version < 2) {
@@ -1106,56 +791,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 version: order.version - 1,
             },
         }, sharedContext);
-        // Returns
-        await this.returnService_.delete({
-            order_id: order.id,
-            order_version: currentVersion,
-        }, sharedContext);
-    }
-    async getActiveOrderChange_(orderId, includeActions, sharedContext) {
-        const options = {
-            select: [
-                "id",
-                "change_type",
-                "order_id",
-                "return_id",
-                "claim_id",
-                "exchange_id",
-                "version",
-                "requested_at",
-                "requested_by",
-                "status",
-            ],
-            relations: [],
-            order: {},
-        };
-        if (includeActions) {
-            options.select.push("actions");
-            options.relations.push("actions");
-            options.order = {
-                actions: {
-                    ordering: "ASC",
-                },
-            };
-        }
-        const [orderChange] = await this.listOrderChanges({
-            order_id: orderId,
-            status: [utils_1.OrderChangeStatus.PENDING, utils_1.OrderChangeStatus.REQUESTED],
-        }, options, sharedContext);
-        return orderChange;
     }
     async getAndValidateOrderChange_(orderChangeIds, includeActions, sharedContext) {
-        orderChangeIds = (0, utils_1.deduplicate)(orderChangeIds);
         const options = {
-            select: [
-                "id",
-                "order_id",
-                "return_id",
-                "claim_id",
-                "exchange_id",
-                "version",
-                "status",
-            ],
+            select: ["id", "order_id", "version", "status"],
             relations: [],
             order: {},
         };
@@ -1193,8 +832,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         const orderChangeMap = {};
         const orderChangeIds = dataArr
             .map((data, idx) => {
+            var _a;
             if (data.order_change_id) {
-                orderChangeMap[data.order_change_id] ??= [];
+                orderChangeMap[_a = data.order_change_id] ?? (orderChangeMap[_a] = []);
                 orderChangeMap[data.order_change_id].push(dataArr[idx]);
             }
             return data.order_change_id;
@@ -1215,6 +855,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         return Array.isArray(data) ? actions : actions[0];
     }
     async applyOrderChanges_(changeActions, sharedContext) {
+        var _a;
         const actionsMap = {};
         const ordersIds = [];
         const usedActions = [];
@@ -1223,7 +864,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 continue;
             }
             ordersIds.push(action.order_id);
-            actionsMap[action.order_id] ??= [];
+            actionsMap[_a = action.order_id] ?? (actionsMap[_a] = []);
             actionsMap[action.order_id].push(action);
             usedActions.push({
                 selector: {
@@ -1235,26 +876,74 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
         }
         if (!ordersIds.length) {
-            return {
-                items: [],
-                shippingMethods: [],
-            };
+            return;
         }
-        let orders = await super.listOrders({ id: (0, utils_1.deduplicate)(ordersIds) }, {
-            select: ["id", "version", "items.detail", "summary", "total"],
-            relations: [
-                "transactions",
-                "items",
+        const orders = await this.list({ id: (0, utils_1.deduplicate)(ordersIds) }, {
+            select: [
+                "id",
+                "version",
                 "items.detail",
-                "shipping_methods",
+                "transactions",
+                "summary",
+                "total",
             ],
+            relations: ["transactions", "items", "items.detail"],
         }, sharedContext);
-        orders = (0, utils_2.formatOrder)(orders, {
-            entity: _models_1.Order,
-        });
-        const { itemsToUpsert, shippingMethodsToUpsert, summariesToUpsert, orderToUpdate, } = (0, utils_2.applyChangesToOrder)(orders, actionsMap, {
-            addActionReferenceToObject: true,
-        });
+        const itemsToUpsert = [];
+        const shippingMethodsToInsert = [];
+        const summariesToUpsert = [];
+        const orderToUpdate = [];
+        for (const order of orders) {
+            const calculated = (0, utils_2.calculateOrderChange)({
+                order: order,
+                actions: actionsMap[order.id],
+                transactions: order.transactions,
+            });
+            (0, utils_1.createRawPropertiesFromBigNumber)(calculated);
+            const version = actionsMap[order.id][0].version;
+            for (const item of calculated.order.items) {
+                const orderItem = item.detail;
+                itemsToUpsert.push({
+                    id: orderItem.version === version ? orderItem.id : undefined,
+                    item_id: item.id,
+                    order_id: order.id,
+                    version,
+                    quantity: item.detail.quantity,
+                    fulfilled_quantity: item.detail.fulfilled_quantity,
+                    shipped_quantity: item.detail.shipped_quantity,
+                    return_requested_quantity: item.detail.return_requested_quantity,
+                    return_received_quantity: item.detail.return_received_quantity,
+                    return_dismissed_quantity: item.detail.return_dismissed_quantity,
+                    written_off_quantity: item.detail.written_off_quantity,
+                    metadata: item.detail.metadata,
+                });
+            }
+            const orderSummary = order.summary;
+            summariesToUpsert.push({
+                id: orderSummary.version === version ? orderSummary.id : undefined,
+                order_id: order.id,
+                version,
+                totals: calculated.summary,
+            });
+            if (version > order.version) {
+                for (const shippingMethod of order.shipping_methods ?? []) {
+                    const sm = {
+                        ...shippingMethod.detail,
+                        version,
+                    };
+                    delete sm.id;
+                    shippingMethodsToInsert.push(sm);
+                }
+                orderToUpdate.push({
+                    selector: {
+                        id: order.id,
+                    },
+                    data: {
+                        version,
+                    },
+                });
+            }
+        }
         await (0, utils_1.promiseAll)([
             orderToUpdate.length
                 ? this.orderService_.update(orderToUpdate, sharedContext)
@@ -1268,378 +957,153 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             summariesToUpsert.length
                 ? this.orderSummaryService_.upsert(summariesToUpsert, sharedContext)
                 : null,
-            shippingMethodsToUpsert.length
-                ? this.orderShippingMethodService_.upsert(shippingMethodsToUpsert, sharedContext)
+            shippingMethodsToInsert.length
+                ? this.orderShippingMethodService_.create(shippingMethodsToInsert, sharedContext)
                 : null,
         ]);
-        return {
-            items: itemsToUpsert,
-            shippingMethods: shippingMethodsToUpsert,
-        };
     }
-    async addTransactions(transactionData, sharedContext) {
-        const orders = await this.orderService_.list({
-            id: Array.isArray(transactionData)
-                ? transactionData.map((t) => t.order_id)
-                : transactionData.order_id,
-        }, {
-            select: ["id", "version"],
-        }, sharedContext);
-        const data = Array.isArray(transactionData)
-            ? transactionData
-            : [transactionData];
-        for (const order of orders) {
-            const trxs = data.filter((t) => t.order_id === order.id);
-            for (const trx of trxs) {
-                ;
-                trx.version = order.version;
-            }
-        }
-        const created = await this.transactionService_.create(data, sharedContext);
-        await this.updateOrderPaidRefundableAmount_(created, false, sharedContext);
-        return await this.baseRepository_.serialize(!Array.isArray(transactionData) ? created[0] : created, {
-            populate: true,
+    async registerFulfillment(data, sharedContext) {
+        const items = data.items.map((item) => {
+            return {
+                action: utils_2.ChangeActionType.FULFILL_ITEM,
+                internal_note: item.internal_note,
+                reference: data.reference,
+                reference_id: data.reference_id,
+                details: {
+                    reference_id: item.id,
+                    quantity: item.quantity,
+                    metadata: item.metadata,
+                },
+            };
         });
-    }
-    // @ts-ignore
-    async deleteTransactions(transactionIds, sharedContext) {
-        const data = Array.isArray(transactionIds)
-            ? transactionIds
-            : [transactionIds];
-        const transactions = await super.listTransactions({
-            id: data,
-        }, {
-            select: ["order_id", "version", "amount"],
+        const change = await this.createOrderChange_({
+            order_id: data.order_id,
+            description: data.description,
+            internal_note: data.internal_note,
+            created_by: data.created_by,
+            metadata: data.metadata,
+            actions: items,
         }, sharedContext);
-        await this.transactionService_.delete(data, sharedContext);
-        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
+        await this.confirmOrderChange(change[0].id, sharedContext);
     }
-    // @ts-ignore
-    async softDeleteTransactions(transactionIds, config, sharedContext) {
-        const transactions = await super.listTransactions({
-            id: transactionIds,
-        }, {
-            select: ["order_id", "amount"],
-        }, sharedContext);
-        const returned = await super.softDeleteTransactions(transactionIds, config, sharedContext);
-        await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
-        return returned;
-    }
-    // @ts-ignore
-    async restoreTransactions(transactionIds, config, sharedContext) {
-        const transactions = await super.listTransactions({
-            id: transactionIds,
-        }, {
-            select: ["order_id", "amount"],
-            withDeleted: true,
-        }, sharedContext);
-        const returned = await super.restoreTransactions(transactionIds, config, sharedContext);
-        await this.updateOrderPaidRefundableAmount_(transactions, false, sharedContext);
-        return returned;
-    }
-    async updateOrderPaidRefundableAmount_(transactionData, isRemoved, sharedContext) {
-        const summaries = await super.listOrderSummaries({
-            order_id: transactionData.map((trx) => trx.order_id),
-        }, {}, sharedContext);
-        summaries.forEach((summary) => {
-            let trxs = transactionData.filter((trx) => trx.order_id === summary.order_id);
-            if (!trxs.length) {
-                return;
-            }
-            (0, utils_1.transformPropertiesToBigNumber)(trxs);
-            const op = isRemoved ? utils_1.MathBN.sub : utils_1.MathBN.add;
-            for (const trx of trxs) {
-                if (utils_1.MathBN.gt(trx.amount, 0)) {
-                    summary.totals.paid_total = new utils_1.BigNumber(op(summary.totals.paid_total, trx.amount));
-                }
-                else {
-                    summary.totals.refunded_total = new utils_1.BigNumber(op(summary.totals.refunded_total, utils_1.MathBN.abs(trx.amount)));
-                }
-            }
-        });
-        (0, utils_1.createRawPropertiesFromBigNumber)(summaries);
-        await this.orderSummaryService_.update(summaries, sharedContext);
-    }
-    async archive(orderId, sharedContext) {
-        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
-            id: orderIds,
-        }, {}, sharedContext);
-        const notAllowed = [];
-        for (const order of orders) {
-            if (![
-                utils_1.OrderStatus.COMPLETED,
-                utils_1.OrderStatus.CANCELED,
-                utils_1.OrderStatus.DRAFT,
-            ].includes(order.status)) {
-                notAllowed.push(order.id);
-            }
-            order.status = utils_1.OrderStatus.ARCHIVED;
+    async registerShipment(data, sharedContext) {
+        let shippingMethodId;
+        if (!(0, utils_1.isString)(data.shipping_method)) {
+            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
+            shippingMethodId = methods[0].id;
         }
-        if (notAllowed.length) {
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are completed, canceled, or in draft and cannot be archived`);
+        else {
+            shippingMethodId = data.shipping_method;
         }
-        await this.orderService_.update({
-            id: orderIds,
-            status: utils_1.OrderStatus.ARCHIVED,
+        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
+            relations: ["tax_lines", "adjustments"],
         }, sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
-    }
-    async completeOrder(orderId, sharedContext) {
-        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
-            id: orderIds,
-        }, {}, sharedContext);
-        const notAllowed = [];
-        for (const order of orders) {
-            if ([utils_1.OrderStatus.CANCELED].includes(order.status)) {
-                notAllowed.push(order.id);
-            }
-            order.status = utils_1.OrderStatus.COMPLETED;
-        }
-        if (notAllowed.length) {
-            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Orders ${notAllowed.join(", ")} are canceled and cannot be completed`);
-        }
-        await this.orderService_.update(orderIds.map((id) => {
+        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
+        const actions = data.items.map((item) => {
             return {
-                id,
-                status: utils_1.OrderStatus.COMPLETED,
+                action: utils_2.ChangeActionType.SHIP_ITEM,
+                internal_note: item.internal_note,
+                reference: data.reference,
+                reference_id: shippingMethodId,
+                details: {
+                    reference_id: item.id,
+                    quantity: item.quantity,
+                    metadata: item.metadata,
+                },
             };
-        }), sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
-    }
-    async cancel(orderId, sharedContext) {
-        const orderIds = Array.isArray(orderId) ? orderId : [orderId];
-        const orders = await this.listOrders({
-            id: orderIds,
-        }, {}, sharedContext);
-        const canceled_at = new Date();
-        for (const order of orders) {
-            order.status = utils_1.OrderStatus.CANCELED;
-            order.canceled_at = canceled_at;
+        });
+        if (shippingMethodId) {
+            actions.push({
+                action: utils_2.ChangeActionType.SHIPPING_ADD,
+                reference: data.reference,
+                reference_id: shippingMethodId,
+                amount: calculatedAmount.total,
+            });
         }
-        await this.orderService_.update(orderIds.map((id) => {
-            return {
-                id,
-                status: utils_1.OrderStatus.CANCELED,
-                canceled_at,
-            };
-        }), sharedContext);
-        return Array.isArray(orderId) ? orders : orders[0];
-    }
-    // ------------------- Bundled Order Actions
-    async createReturn(data, sharedContext) {
-        const ret = await BundledActions.createReturn.bind(this)(data, sharedContext);
-        return await this.retrieveReturn(ret.id, {
-            relations: [
-                "items",
-                "shipping_methods",
-                "shipping_methods.tax_lines",
-                "shipping_methods.adjustments",
-            ],
+        const change = await this.createOrderChange_({
+            order_id: data.order_id,
+            description: data.description,
+            internal_note: data.internal_note,
+            created_by: data.created_by,
+            metadata: data.metadata,
+            actions,
         }, sharedContext);
+        await this.confirmOrderChange(change[0].id, sharedContext);
     }
-    async receiveReturn(data, sharedContext) {
-        const ret = await this.receiveReturn_(data, sharedContext);
-        return await this.retrieveReturn(ret.id, {
-            relations: [
-                "items",
-                "shipping_methods",
-                "shipping_methods.tax_lines",
-                "shipping_methods.adjustments",
-            ],
-        });
-    }
-    async receiveReturn_(data, sharedContext) {
-        return await BundledActions.receiveReturn.bind(this)(data, sharedContext);
-    }
-    async cancelReturn(data, sharedContext) {
-        const ret = await this.cancelReturn_(data, sharedContext);
-        return await this.retrieveReturn(ret.id, {
-            relations: [
-                "items",
-                "shipping_methods",
-                "shipping_methods.tax_lines",
-                "shipping_methods.adjustments",
-            ],
-        });
-    }
-    async cancelReturn_(data, sharedContext) {
-        return await BundledActions.cancelReturn.bind(this)(data, sharedContext);
-    }
-    async createClaim(data, sharedContext) {
-        const ret = await this.createClaim_(data, sharedContext);
-        const claim = await this.retrieveOrderClaim(ret.id, {
-            relations: [
-                "additional_items",
-                "additional_items.item",
-                "claim_items",
-                "claim_items.item",
-                "return",
-                "return.items",
-                "shipping_methods",
-                "shipping_methods.tax_lines",
-                "shipping_methods.adjustments",
-                "transactions",
-            ],
+    async createReturn(data, sharedContext) {
+        let shippingMethodId;
+        if (!(0, utils_1.isString)(data.shipping_method)) {
+            const methods = await this.createShippingMethods(data.order_id, data.shipping_method, sharedContext);
+            shippingMethodId = methods[0].id;
+        }
+        else {
+            shippingMethodId = data.shipping_method;
+        }
+        const method = await this.shippingMethodService_.retrieve(shippingMethodId, {
+            relations: ["tax_lines", "adjustments"],
         }, sharedContext);
-        return await this.baseRepository_.serialize(claim, {
-            populate: true,
-        });
-    }
-    async createClaim_(data, sharedContext) {
-        return await BundledActions.createClaim.bind(this)(data, sharedContext);
-    }
-    async cancelClaim(data, sharedContext) {
-        const ret = await this.cancelClaim_(data, sharedContext);
-        return await this.retrieveOrderClaim(ret.id, {
-            relations: ["items"],
+        const calculatedAmount = (0, utils_1.getShippingMethodsTotals)([method], {})[method.id];
+        const actions = data.items.map((item) => {
+            return {
+                action: utils_2.ChangeActionType.RETURN_ITEM,
+                internal_note: item.internal_note,
+                reference: data.reference,
+                reference_id: shippingMethodId,
+                details: {
+                    reference_id: item.id,
+                    quantity: item.quantity,
+                    metadata: item.metadata,
+                },
+            };
         });
-    }
-    async cancelClaim_(data, sharedContext) {
-        return await BundledActions.cancelClaim.bind(this)(data, sharedContext);
-    }
-    async createExchange(data, sharedContext) {
-        const ret = await this.createExchange_(data, sharedContext);
-        const claim = await this.retrieveOrderExchange(ret.id, {
-            relations: [
-                "additional_items",
-                "additional_items.item",
-                "return",
-                "return.items",
-                "shipping_methods",
-                "shipping_methods.tax_lines",
-                "shipping_methods.adjustments",
-                "transactions",
-            ],
+        if (shippingMethodId) {
+            actions.push({
+                action: utils_2.ChangeActionType.SHIPPING_ADD,
+                reference: data.reference,
+                reference_id: shippingMethodId,
+                amount: calculatedAmount.total,
+            });
+        }
+        const change = await this.createOrderChange_({
+            order_id: data.order_id,
+            description: data.description,
+            internal_note: data.internal_note,
+            created_by: data.created_by,
+            metadata: data.metadata,
+            actions,
         }, sharedContext);
-        return await this.baseRepository_.serialize(claim, {
-            populate: true,
-        });
-    }
-    async createExchange_(data, sharedContext) {
-        return await BundledActions.createExchange.bind(this)(data, sharedContext);
-    }
-    async cancelExchange(data, sharedContext) {
-        const ret = await this.cancelExchange_(data, sharedContext);
-        return await this.retrieveOrderExchange(ret.id, {
-            relations: ["items"],
-        });
-    }
-    async cancelExchange_(data, sharedContext) {
-        return await BundledActions.cancelExchange.bind(this)(data, sharedContext);
-    }
-    async registerFulfillment(data, sharedContext) {
-        return await BundledActions.registerFulfillment.bind(this)(data, sharedContext);
-    }
-    async cancelFulfillment(data, sharedContext) {
-        return await BundledActions.cancelFulfillment.bind(this)(data, sharedContext);
-    }
-    async registerShipment(data, sharedContext) {
-        return await BundledActions.registerShipment.bind(this)(data, sharedContext);
+        await this.confirmOrderChange(change[0].id, sharedContext);
     }
 }
 exports.default = OrderModuleService;
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveOrder", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listOrders", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountOrders", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveReturn", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listReturns", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountReturns", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveOrderClaim", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listOrderClaims", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountOrderClaims", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "retrieveOrderExchange", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listOrderExchanges", null);
-__decorate([
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "listAndCountOrderExchanges", 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, "createOrders", null);
+], 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, "createOrders_", null);
+], OrderModuleService.prototype, "create_", 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, "updateOrders", null);
+], OrderModuleService.prototype, "update", 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, "updateOrders_", null);
+], OrderModuleService.prototype, "update_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1752,24 +1216,6 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "createShippingMethodsBulk_", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "softDeleteShippingMethods", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "restoreShippingMethods", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1826,84 +1272,44 @@ __decorate([
     __metadata("design:paramtypes", [String, Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "setShippingMethodTaxLines", 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, "createReturns", 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, "createOrderClaims", 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, "createOrderExchanges", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createOrderRelatedEntity_", 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, "createOrderChange", 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, "createOrderChange_", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "previewOrderChange", 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, "cancelOrderChange", 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, "confirmOrderChange", 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, "declineOrderChange", 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, "applyPendingOrderActions", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
-    __param(1, (0, utils_1.MedusaContext)()),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, Object]),
     __metadata("design:returntype", Promise)
@@ -1916,182 +1322,26 @@ __decorate([
 ], OrderModuleService.prototype, "revertLastChange_", 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, "addOrderAction", 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, "addTransactions", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
-    __param(1, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "deleteTransactions", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "softDeleteTransactions", null);
-__decorate([
-    (0, utils_1.InjectManager)("baseRepository_")
-    // @ts-ignore
-    ,
-    __param(2, (0, utils_1.MedusaContext)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object, Object, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "restoreTransactions", null);
-__decorate([
-    (0, utils_1.InjectTransactionManager)("baseRepository_"),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Array, Boolean, Object]),
-    __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "updateOrderPaidRefundableAmount_", 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, "archive", 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, "completeOrder", 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, "cancel", 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, "createReturn", 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, "receiveReturn", 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, "receiveReturn_", 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, "cancelReturn", 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, "cancelReturn_", 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, "createClaim", 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, "createClaim_", 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, "cancelClaim", 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, "cancelClaim_", 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, "createExchange", 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, "createExchange_", 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, "cancelExchange", 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, "cancelExchange_", 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, "registerFulfillment", 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, "cancelFulfillment", null);
+], OrderModuleService.prototype, "registerShipment", 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, "registerShipment", null);
+], OrderModuleService.prototype, "createReturn", null);
 //# sourceMappingURL=order-module-service.js.map