@medusajs/order 0.1.3-snapshot-20240827104434 → 0.1.3-snapshot-20240904063643

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

@@ -42,19 +42,19 @@ 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,
+    OrderAddress: _models_1.OrderAddress,
+    OrderLineItem: _models_1.OrderLineItem,
+    OrderLineItemAdjustment: _models_1.OrderLineItemAdjustment,
+    OrderLineItemTaxLine: _models_1.OrderLineItemTaxLine,
+    OrderShippingMethod: _models_1.OrderShippingMethod,
+    OrderShippingMethodAdjustment: _models_1.OrderShippingMethodAdjustment,
+    OrderShippingMethodTaxLine: _models_1.OrderShippingMethodTaxLine,
+    OrderTransaction: _models_1.OrderTransaction,
     OrderChange: _models_1.OrderChange,
     OrderChangeAction: _models_1.OrderChangeAction,
     OrderItem: _models_1.OrderItem,
     OrderSummary: _models_1.OrderSummary,
-    OrderShippingMethod: _models_1.OrderShippingMethod,
+    OrderShipping: _models_1.OrderShipping,
     ReturnReason: _models_1.ReturnReason,
     Return: _models_1.Return,
     ReturnItem: _models_1.ReturnItem,
@@ -66,25 +66,26 @@ const generateMethodForModels = {
 };
 // 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) {
+    constructor({ baseRepository, orderService, orderAddressService, orderLineItemService, orderShippingMethodAdjustmentService, orderShippingMethodService, orderLineItemAdjustmentService, orderShippingMethodTaxLineService, orderLineItemTaxLineService, orderTransactionService, orderChangeService, orderChangeActionService, orderItemService, orderSummaryService, orderShippingService, returnReasonService, returnService, returnItemService, orderClaimService, orderExchangeService, }, 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;
-        this.transactionService_ = transactionService;
+        this.orderAddressService_ = orderAddressService;
+        this.orderLineItemService_ = orderLineItemService;
+        this.orderShippingMethodAdjustmentService_ =
+            orderShippingMethodAdjustmentService;
+        this.orderShippingMethodService_ = orderShippingMethodService;
+        this.orderLineItemAdjustmentService_ = orderLineItemAdjustmentService;
+        this.orderShippingMethodTaxLineService_ = orderShippingMethodTaxLineService;
+        this.orderLineItemTaxLineService_ = orderLineItemTaxLineService;
+        this.orderTransactionService_ = orderTransactionService;
         this.orderChangeService_ = orderChangeService;
         this.orderChangeActionService_ = orderChangeActionService;
         this.orderItemService_ = orderItemService;
         this.orderSummaryService_ = orderSummaryService;
-        this.orderShippingMethodService_ = orderShippingMethodService;
+        this.orderShippingService_ = orderShippingService;
         this.returnReasonService_ = returnReasonService;
         this.returnService_ = returnService;
         this.returnItemService_ = returnItemService;
@@ -331,7 +332,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         }
         if (lineItemsToCreate.length) {
-            await this.createLineItemsBulk_(lineItemsToCreate, sharedContext);
+            await this.createOrderLineItemsBulk_(lineItemsToCreate, sharedContext);
         }
         return createdOrders;
     }
@@ -367,10 +368,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         const result = await this.orderService_.update(toUpdate, sharedContext);
         return result;
     }
-    async createLineItems(orderIdOrData, data, sharedContext = {}) {
+    async createOrderLineItems(orderIdOrData, data, sharedContext = {}) {
         let items = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
-            items = await this.createLineItems_(orderIdOrData, data, sharedContext);
+            items = await this.createOrderLineItems_(orderIdOrData, data, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
@@ -388,13 +389,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     version: mapOrderVersion[dt.order_id],
                 };
             });
-            items = await this.createLineItemsBulk_(lineItems, sharedContext);
+            items = await this.createOrderLineItemsBulk_(lineItems, sharedContext);
         }
         return await this.baseRepository_.serialize(items, {
             populate: true,
         });
     }
-    async createLineItems_(orderId, items, sharedContext = {}) {
+    async createOrderLineItems_(orderId, items, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
         const toUpdate = items.map((item) => {
             return {
@@ -403,11 +404,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 version: order.version,
             };
         });
-        return await this.createLineItemsBulk_(toUpdate, sharedContext);
+        return await this.createOrderLineItemsBulk_(toUpdate, sharedContext);
     }
-    async createLineItemsBulk_(data, sharedContext = {}) {
+    async createOrderLineItemsBulk_(data, sharedContext = {}) {
         const orderItemToCreate = [];
-        const lineItems = await this.lineItemService_.create(data, sharedContext);
+        const lineItems = await this.orderLineItemService_.create(data, sharedContext);
         for (let i = 0; i < lineItems.length; i++) {
             const item = lineItems[i];
             const toCreate = data[i];
@@ -425,10 +426,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return lineItems;
     }
-    async updateLineItems(lineItemIdOrDataOrSelector, data, sharedContext = {}) {
+    async updateOrderLineItems(lineItemIdOrDataOrSelector, data, sharedContext = {}) {
         let items = [];
         if ((0, utils_1.isString)(lineItemIdOrDataOrSelector)) {
-            const item = await this.updateLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
+            const item = await this.updateOrderLineItem_(lineItemIdOrDataOrSelector, data, sharedContext);
             return await this.baseRepository_.serialize(item, {
                 populate: true,
             });
@@ -441,13 +442,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     data: data,
                 },
             ];
-        items = await this.updateLineItemsWithSelector_(toUpdate, sharedContext);
+        items = await this.updateOrderLineItemsWithSelector_(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);
+    async updateOrderLineItem_(lineItemId, data, sharedContext = {}) {
+        const [item] = await this.orderLineItemService_.update([{ id: lineItemId, ...data }], sharedContext);
         if ("quantity" in data) {
             await this.updateOrderItemWithSelector_([
                 {
@@ -458,11 +459,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return item;
     }
-    async updateLineItemsWithSelector_(updates, sharedContext = {}) {
+    async updateOrderLineItemsWithSelector_(updates, sharedContext = {}) {
         let toUpdate = [];
         const detailsToUpdate = [];
         for (const { selector, data } of updates) {
-            const items = await this.listLineItems({ ...selector }, {}, sharedContext);
+            const items = await this.listOrderLineItems({ ...selector }, {}, sharedContext);
             items.forEach((item) => {
                 toUpdate.push({
                     ...data,
@@ -479,7 +480,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         if (detailsToUpdate.length) {
             await this.updateOrderItemWithSelector_(detailsToUpdate, sharedContext);
         }
-        return await this.lineItemService_.update(toUpdate, sharedContext);
+        return await this.orderLineItemService_.update(toUpdate, sharedContext);
     }
     async updateOrderItem(orderItemIdOrDataOrSelector, data, sharedContext = {}) {
         let items = [];
@@ -519,28 +520,10 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return await this.orderItemService_.update(toUpdate, 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 createShippingMethods(orderIdOrData, data, sharedContext = {}) {
+    async createOrderShippingMethods(orderIdOrData, data, sharedContext = {}) {
         let methods;
         if ((0, utils_1.isString)(orderIdOrData)) {
-            methods = await this.createShippingMethods_(orderIdOrData, data, sharedContext);
+            methods = await this.createOrderShippingMethods_(orderIdOrData, data, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
@@ -562,11 +545,11 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     version: dt.version ?? mapOrderVersion[dt.order_id],
                 };
             });
-            methods = await this.createShippingMethodsBulk_(orderShippingMethodData, sharedContext);
+            methods = await this.createOrderShippingMethodsBulk_(orderShippingMethodData, sharedContext);
         }
         return await this.baseRepository_.serialize(methods, { populate: true });
     }
-    async createShippingMethods_(orderId, data, sharedContext = {}) {
+    async createOrderShippingMethods_(orderId, data, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id", "version"] }, sharedContext);
         const methods = data.map((methodData) => {
             return {
@@ -578,41 +561,41 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 version: methodData.version ?? order.version ?? 1,
             };
         });
-        return await this.createShippingMethodsBulk_(methods, sharedContext);
+        return await this.createOrderShippingMethodsBulk_(methods, sharedContext);
     }
-    async createShippingMethodsBulk_(data, sharedContext = {}) {
-        const sm = await this.orderShippingMethodService_.create(data, sharedContext);
+    async createOrderShippingMethodsBulk_(data, sharedContext = {}) {
+        const sm = await this.orderShippingService_.create(data, sharedContext);
         return sm.map((s) => s.shipping_method);
     }
     // @ts-ignore
-    async softDeleteShippingMethods(ids, config, sharedContext) {
-        const rel = await super.listOrderShippingMethods({
+    async softDeleteOrderShippingMethods(ids, config, sharedContext) {
+        const rel = await super.listOrderShippings({
             shipping_method_id: ids,
         }, {
             select: ["id"],
         }, sharedContext);
-        const orderShippingMethodIds = rel.map((r) => r.id);
+        const orderShippingIds = rel.map((r) => r.id);
         const [returned] = await (0, utils_1.promiseAll)([
-            super.softDeleteShippingMethods(ids, config, sharedContext),
-            super.softDeleteOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
+            super.softDeleteOrderShippingMethods(ids, config, sharedContext),
+            super.softDeleteOrderShippings(orderShippingIds, config, sharedContext),
         ]);
         return returned;
     }
     // @ts-ignore
-    async restoreShippingMethods(transactionIds, config, sharedContext) {
-        const rel = await super.listOrderShippingMethods({
-            shipping_method_id: transactionIds,
+    async restoreOrderShippingMethods(ids, config, sharedContext) {
+        const rel = await super.listOrderShippings({
+            shipping_method_id: ids,
         }, {
             select: ["id"],
         }, sharedContext);
-        const orderShippingMethodIds = rel.map((r) => r.id);
+        const shippingIds = rel.map((r) => r.id);
         const [returned] = await (0, utils_1.promiseAll)([
-            super.restoreShippingMethods(transactionIds, config, sharedContext),
-            super.restoreOrderShippingMethods(orderShippingMethodIds, config, sharedContext),
+            super.restoreOrderShippingMethods(ids, config, sharedContext),
+            super.restoreOrderShippings(shippingIds, config, sharedContext),
         ]);
         return returned;
     }
-    async createLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+    async createOrderLineItemAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
             const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["items.item"] }, sharedContext);
@@ -622,19 +605,19 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     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);
+            addedAdjustments = await this.orderLineItemAdjustmentService_.create(adjustments, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedAdjustments = await this.lineItemAdjustmentService_.create(data, sharedContext);
+            addedAdjustments = await this.orderLineItemAdjustmentService_.create(data, sharedContext);
         }
         return await this.baseRepository_.serialize(addedAdjustments, {
             populate: true,
         });
     }
-    async setLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
+    async setOrderLineItemAdjustments(orderId, adjustments, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.adjustments"] }, sharedContext);
         const existingAdjustments = (order.items ?? [])
             .map((item) => item.adjustments ?? [])
@@ -651,14 +634,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         });
         if (toDelete.length) {
-            await this.lineItemAdjustmentService_.delete(toDelete, sharedContext);
+            await this.orderLineItemAdjustmentService_.delete(toDelete, sharedContext);
         }
-        let result = await this.lineItemAdjustmentService_.upsert(adjustments, sharedContext);
+        let result = await this.orderLineItemAdjustmentService_.upsert(adjustments, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async setShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
+    async setOrderShippingMethodAdjustments(orderId, adjustments, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.adjustments"] }, sharedContext);
         const existingAdjustments = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.adjustments ?? [])
@@ -675,14 +658,14 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         });
         if (toDelete.length) {
-            await this.shippingMethodAdjustmentService_.delete(toDelete, sharedContext);
+            await this.orderShippingMethodAdjustmentService_.delete(toDelete, sharedContext);
         }
-        const result = await this.shippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
+        const result = await this.orderShippingMethodAdjustmentService_.upsert(adjustments, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async createShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
+    async createOrderShippingMethodAdjustments(orderIdOrData, adjustments, sharedContext = {}) {
         let addedAdjustments = [];
         if ((0, utils_1.isString)(orderIdOrData)) {
             const order = await this.retrieveOrder(orderIdOrData, { select: ["id"], relations: ["shipping_methods"] }, sharedContext);
@@ -692,13 +675,15 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                     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);
+            addedAdjustments =
+                await this.orderShippingMethodAdjustmentService_.create(adjustments, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedAdjustments = await this.shippingMethodAdjustmentService_.create(data, sharedContext);
+            addedAdjustments =
+                await this.orderShippingMethodAdjustmentService_.create(data, sharedContext);
         }
         if ((0, utils_1.isObject)(orderIdOrData)) {
             return await this.baseRepository_.serialize(addedAdjustments[0], {
@@ -709,17 +694,17 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             populate: true,
         });
     }
-    async createLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+    async createOrderLineItemTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
-            addedTaxLines = await this.lineItemTaxLineService_.create(lines, sharedContext);
+            addedTaxLines = await this.orderLineItemTaxLineService_.create(lines, sharedContext);
         }
         else {
             const data = Array.isArray(orderIdOrData)
                 ? orderIdOrData
                 : [orderIdOrData];
-            addedTaxLines = await this.lineItemTaxLineService_.create(data, sharedContext);
+            addedTaxLines = await this.orderLineItemTaxLineService_.create(data, sharedContext);
         }
         const serialized = await this.baseRepository_.serialize(addedTaxLines, {
             populate: true,
@@ -729,7 +714,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return serialized;
     }
-    async setLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
+    async setOrderLineItemTaxLines(orderId, taxLines, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["items.item.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.items ?? [])
             .map((item) => item.tax_lines ?? [])
@@ -745,21 +730,21 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         });
         if (toDelete.length) {
-            await this.lineItemTaxLineService_.delete(toDelete, sharedContext);
+            await this.orderLineItemTaxLineService_.delete(toDelete, sharedContext);
         }
-        const result = await this.lineItemTaxLineService_.upsert(taxLines, sharedContext);
+        const result = await this.orderLineItemTaxLineService_.upsert(taxLines, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
     }
-    async createShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
+    async createOrderShippingMethodTaxLines(orderIdOrData, taxLines, sharedContext = {}) {
         let addedTaxLines;
         if ((0, utils_1.isString)(orderIdOrData)) {
             const lines = Array.isArray(taxLines) ? taxLines : [taxLines];
-            addedTaxLines = await this.shippingMethodTaxLineService_.create(lines, sharedContext);
+            addedTaxLines = await this.orderShippingMethodTaxLineService_.create(lines, sharedContext);
         }
         else {
-            addedTaxLines = await this.shippingMethodTaxLineService_.create(taxLines, sharedContext);
+            addedTaxLines = await this.orderShippingMethodTaxLineService_.create(taxLines, sharedContext);
         }
         const serialized = await this.baseRepository_.serialize(addedTaxLines[0], {
             populate: true,
@@ -769,7 +754,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }
         return serialized;
     }
-    async setShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
+    async setOrderShippingMethodTaxLines(orderId, taxLines, sharedContext = {}) {
         const order = await this.retrieveOrder(orderId, { select: ["id"], relations: ["shipping_methods.tax_lines"] }, sharedContext);
         const existingTaxLines = (order.shipping_methods ?? [])
             .map((shippingMethod) => shippingMethod.tax_lines ?? [])
@@ -785,9 +770,9 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         });
         if (toDelete.length) {
-            await this.shippingMethodTaxLineService_.delete(toDelete, sharedContext);
+            await this.orderShippingMethodTaxLineService_.delete(toDelete, sharedContext);
         }
-        const result = await this.shippingMethodTaxLineService_.upsert(taxLines, sharedContext);
+        const result = await this.orderShippingMethodTaxLineService_.upsert(taxLines, sharedContext);
         return await this.baseRepository_.serialize(result, {
             populate: true,
         });
@@ -874,16 +859,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             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 = {};
@@ -900,7 +875,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             }
         }
         if (Object.keys(addedItems).length > 0) {
-            const addedItemDetails = await this.listLineItems({ id: Object.keys(addedItems) }, {
+            const addedItemDetails = await this.listOrderLineItems({ id: Object.keys(addedItems) }, {
                 relations: ["adjustments", "tax_lines"],
             }, sharedContext);
             calculated.order.items.forEach((item, idx) => {
@@ -923,7 +898,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             });
         }
         if (Object.keys(addedShippingMethods).length > 0) {
-            const addedShippingDetails = await this.listShippingMethods({ id: Object.keys(addedShippingMethods) }, {
+            const addedShippingDetails = await this.listOrderShippingMethods({ id: Object.keys(addedShippingMethods) }, {
                 relations: ["adjustments", "tax_lines"],
             }, sharedContext);
             calculated.order.shipping_methods.forEach((sm, idx) => {
@@ -986,16 +961,6 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         });
         await this.orderChangeService_.update(updates, sharedContext);
         const orderChanges = orderChange.map((change) => {
-            change.actions = change.actions.map((action) => {
-                return {
-                    ...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);
@@ -1089,13 +1054,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
         }, { select: ["id", "version"] }, sharedContext);
         const orderItemIds = orderItems.map((summary) => summary.id);
         await this.orderItemService_.softDelete(orderItemIds, sharedContext);
-        // Shipping Methods
-        const orderShippingMethods = await this.orderShippingMethodService_.list({
+        // Order Shipping
+        const orderShippings = await this.orderShippingService_.list({
             order_id: order.id,
             version: currentVersion,
         }, { select: ["id", "version"] }, sharedContext);
-        const orderShippingMethodIds = orderShippingMethods.map((summary) => summary.id);
-        await this.orderShippingMethodService_.softDelete(orderShippingMethodIds, sharedContext);
+        const orderShippingIds = orderShippings.map((sh) => sh.id);
+        await this.orderShippingService_.softDelete(orderShippingIds, sharedContext);
         // Order
         await this.orderService_.update({
             selector: {
@@ -1273,7 +1238,7 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 ? this.orderSummaryService_.upsert(summariesToUpsert, sharedContext)
                 : null,
             shippingMethodsToUpsert.length
-                ? this.orderShippingMethodService_.upsert(shippingMethodsToUpsert, sharedContext)
+                ? this.orderShippingService_.upsert(shippingMethodsToUpsert, sharedContext)
                 : null,
         ]);
         return {
@@ -1281,12 +1246,13 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
             shippingMethods: shippingMethodsToUpsert,
         };
     }
-    async addTransactions(transactionData, sharedContext) {
+    async addOrderTransactions(transactionData, sharedContext) {
         const orders = await this.orderService_.list({
             id: Array.isArray(transactionData)
                 ? transactionData.map((t) => t.order_id)
                 : transactionData.order_id,
         }, {
+            take: null,
             select: ["id", "version"],
         }, sharedContext);
         const data = Array.isArray(transactionData)
@@ -1299,52 +1265,55 @@ class OrderModuleService extends utils_1.ModulesSdkUtils.MedusaService(generateM
                 trx.version = order.version;
             }
         }
-        const created = await this.transactionService_.create(data, sharedContext);
+        const created = await this.orderTransactionService_.create(data, sharedContext);
         await this.updateOrderPaidRefundableAmount_(created, false, sharedContext);
         return await this.baseRepository_.serialize(!Array.isArray(transactionData) ? created[0] : created, {
             populate: true,
         });
     }
     // @ts-ignore
-    async deleteTransactions(transactionIds, sharedContext) {
+    async deleteOrderTransactions(transactionIds, sharedContext) {
         const data = Array.isArray(transactionIds)
             ? transactionIds
             : [transactionIds];
-        const transactions = await super.listTransactions({
+        const transactions = await super.listOrderTransactions({
             id: data,
         }, {
             select: ["order_id", "version", "amount"],
+            take: null,
         }, sharedContext);
-        await this.transactionService_.delete(data, sharedContext);
+        await this.orderTransactionService_.delete(data, sharedContext);
         await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
     }
     // @ts-ignore
-    async softDeleteTransactions(transactionIds, config, sharedContext) {
-        const transactions = await super.listTransactions({
+    async softDeleteOrderTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listOrderTransactions({
             id: transactionIds,
         }, {
+            take: null,
             select: ["order_id", "amount"],
         }, sharedContext);
-        const returned = await super.softDeleteTransactions(transactionIds, config, sharedContext);
+        const returned = await super.softDeleteOrderTransactions(transactionIds, config, sharedContext);
         await this.updateOrderPaidRefundableAmount_(transactions, true, sharedContext);
         return returned;
     }
     // @ts-ignore
-    async restoreTransactions(transactionIds, config, sharedContext) {
-        const transactions = await super.listTransactions({
+    async restoreOrderTransactions(transactionIds, config, sharedContext) {
+        const transactions = await super.listOrderTransactions({
             id: transactionIds,
         }, {
             select: ["order_id", "amount"],
             withDeleted: true,
+            take: null,
         }, sharedContext);
-        const returned = await super.restoreTransactions(transactionIds, config, sharedContext);
+        const returned = await super.restoreOrderTransactions(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);
+        }, { take: null }, sharedContext);
         summaries.forEach((summary) => {
             let trxs = transactionData.filter((trx) => trx.order_id === summary.order_id);
             if (!trxs.length) {
@@ -1672,42 +1641,42 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "createLineItems", null);
+], OrderModuleService.prototype, "createOrderLineItems", 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, "createLineItems_", null);
+], OrderModuleService.prototype, "createOrderLineItems_", 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, "createLineItemsBulk_", null);
+], OrderModuleService.prototype, "createOrderLineItemsBulk_", 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);
+], OrderModuleService.prototype, "updateOrderLineItems", 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);
+], OrderModuleService.prototype, "updateOrderLineItem_", 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);
+], OrderModuleService.prototype, "updateOrderLineItemsWithSelector_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_"),
     __param(2, (0, utils_1.MedusaContext)()),
@@ -1729,55 +1698,27 @@ __decorate([
     __metadata("design:paramtypes", [Array, Object]),
     __metadata("design:returntype", Promise)
 ], OrderModuleService.prototype, "updateOrderItemWithSelector_", 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, "createShippingMethods", null);
+], OrderModuleService.prototype, "createOrderShippingMethods", 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, "createShippingMethods_", null);
+], OrderModuleService.prototype, "createOrderShippingMethods_", 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, "createShippingMethodsBulk_", null);
+], OrderModuleService.prototype, "createOrderShippingMethodsBulk_", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-ignore
@@ -1786,7 +1727,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "softDeleteShippingMethods", null);
+], OrderModuleService.prototype, "softDeleteOrderShippingMethods", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-ignore
@@ -1795,63 +1736,63 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "restoreShippingMethods", null);
+], OrderModuleService.prototype, "restoreOrderShippingMethods", 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, "createLineItemAdjustments", null);
+], OrderModuleService.prototype, "createOrderLineItemAdjustments", 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);
+], OrderModuleService.prototype, "setOrderLineItemAdjustments", 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);
+], OrderModuleService.prototype, "setOrderShippingMethodAdjustments", 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, "createShippingMethodAdjustments", null);
+], OrderModuleService.prototype, "createOrderShippingMethodAdjustments", 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, "createLineItemTaxLines", null);
+], OrderModuleService.prototype, "createOrderLineItemTaxLines", 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);
+], OrderModuleService.prototype, "setOrderLineItemTaxLines", 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, "createShippingMethodTaxLines", null);
+], OrderModuleService.prototype, "createOrderShippingMethodTaxLines", 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);
+], OrderModuleService.prototype, "setOrderShippingMethodTaxLines", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __param(1, (0, utils_1.MedusaContext)()),
@@ -1959,7 +1900,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "addTransactions", null);
+], OrderModuleService.prototype, "addOrderTransactions", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-ignore
@@ -1968,7 +1909,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "deleteTransactions", null);
+], OrderModuleService.prototype, "deleteOrderTransactions", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-ignore
@@ -1977,7 +1918,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "softDeleteTransactions", null);
+], OrderModuleService.prototype, "softDeleteOrderTransactions", null);
 __decorate([
     (0, utils_1.InjectManager)("baseRepository_")
     // @ts-ignore
@@ -1986,7 +1927,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object, Object]),
     __metadata("design:returntype", Promise)
-], OrderModuleService.prototype, "restoreTransactions", null);
+], OrderModuleService.prototype, "restoreOrderTransactions", null);
 __decorate([
     (0, utils_1.InjectTransactionManager)("baseRepository_"),
     __metadata("design:type", Function),