order-management 0.0.24 → 0.0.26

package/.medusa/server/src/workflows/steps/swap/create-medusa-return-step.js

@@ -13,16 +13,83 @@ exports.createMedusaReturnStep = (0, workflows_sdk_1.createStep)("create-medusa-
     const swapService = container.resolve(swap_1.SWAP_MODULE);
     const swap = await swapService.retrieveSwap(swap_id);
     const swapData = swap;
+    // Log swap data for debugging
+    console.log("[Create Medusa Return] Swap data retrieved:", {
+        swap_id,
+        order_id: swapData.order_id,
+        return_items_raw: swapData.return_items,
+        return_items_type: typeof swapData.return_items,
+        return_items_is_array: Array.isArray(swapData.return_items),
+        status: swapData.status,
+    });
     if (!swapData.order_id) {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Swap must have an order_id");
     }
     if (swapData.return_id) {
         // Return already created
+        console.log("[Create Medusa Return] Return already exists for this swap:", {
+            swap_id,
+            return_id: swapData.return_id,
+        });
         return new workflows_sdk_1.StepResponse({
             return_id: swapData.return_id,
             swap,
         });
     }
+    // Check for existing returns/exchanges for this order that might conflict
+    try {
+        const remoteQuery = container.resolve(utils_2.ContainerRegistrationKeys.REMOTE_QUERY);
+        // Query for existing returns on this order
+        const existingReturnsQuery = (0, utils_2.remoteQueryObjectFromString)({
+            entryPoint: "return",
+            fields: ["id", "order_id", "items.*"],
+            filters: {
+                order_id: [swapData.order_id],
+            },
+        });
+        const existingReturns = await remoteQuery(existingReturnsQuery);
+        const returnsArray = Array.isArray(existingReturns) ? existingReturns : existingReturns ? [existingReturns] : [];
+        if (returnsArray.length > 0) {
+            console.warn("[Create Medusa Return] Found existing returns for this order:", {
+                order_id: swapData.order_id,
+                existing_returns_count: returnsArray.length,
+                existing_returns: returnsArray.map((ret) => {
+                    const retData = ret;
+                    return {
+                        id: retData.id,
+                        item_ids: retData.items?.map((item) => item.id) || [],
+                    };
+                }),
+            });
+        }
+        // Query for existing exchanges on this order
+        const existingExchangesQuery = (0, utils_2.remoteQueryObjectFromString)({
+            entryPoint: "exchange",
+            fields: ["id", "order_id", "return_id"],
+            filters: {
+                order_id: [swapData.order_id],
+            },
+        });
+        const existingExchanges = await remoteQuery(existingExchangesQuery);
+        const exchangesArray = Array.isArray(existingExchanges) ? existingExchanges : existingExchanges ? [existingExchanges] : [];
+        if (exchangesArray.length > 0) {
+            console.warn("[Create Medusa Return] Found existing exchanges for this order:", {
+                order_id: swapData.order_id,
+                existing_exchanges_count: exchangesArray.length,
+                existing_exchanges: exchangesArray.map((ex) => {
+                    const exData = ex;
+                    return {
+                        id: exData.id,
+                        return_id: exData.return_id,
+                    };
+                }),
+            });
+        }
+    }
+    catch (queryError) {
+        // Log but don't fail - this is just for debugging
+        console.warn("[Create Medusa Return] Failed to query existing returns/exchanges:", queryError);
+    }
     // Allow creating return if status is "approved" OR "requested" with pending_exchange_creation flag
     const swapMetadata = swapData.metadata || {};
     const pendingExchangeCreation = swapMetadata.pending_exchange_creation === true;
@@ -31,41 +98,93 @@ exports.createMedusaReturnStep = (0, workflows_sdk_1.createStep)("create-medusa-
     }
     // Use return_items from input if provided, otherwise parse from swap model
     let returnItems = [];
+    console.log("[Create Medusa Return] Processing return items:", {
+        has_input_return_items: !!inputReturnItems,
+        input_return_items_count: inputReturnItems?.length || 0,
+        swap_return_items: swapData.return_items,
+    });
     if (inputReturnItems && inputReturnItems.length > 0) {
         // Use items from input (from exchange form)
-        returnItems = inputReturnItems.map((item) => ({
-            id: item.item_id,
+        console.log("[Create Medusa Return] Using input return items:", inputReturnItems);
+        returnItems = inputReturnItems
+            .filter((item) => {
+            const itemId = item.id;
+            return itemId && typeof itemId === "string" && itemId.trim() !== "";
+        })
+            .map((item) => ({
+            id: item.id,
             quantity: item.quantity,
             reason: item.reason_id,
+            variant_id: item.variant_id, // Preserve variant_id if provided
         }));
+        console.log("[Create Medusa Return] Parsed input return items:", returnItems);
     }
     else {
         // Parse return_items from JSONB format in swap model
         if (swapData.return_items) {
             if (Array.isArray(swapData.return_items)) {
-                returnItems = swapData.return_items.map((item) => ({
-                    id: String(item.id || item.item_id || ""),
-                    quantity: Number(item.quantity || 0),
-                    reason: item.reason,
-                }));
+                returnItems = swapData.return_items
+                    .filter((item) => {
+                    const itemData = item;
+                    const itemId = itemData.id || itemData.item_id;
+                    return !!itemId && typeof itemId === "string" && itemId.trim() !== "" && (itemData.quantity || 0) > 0;
+                })
+                    .map((item) => {
+                    const itemData = item;
+                    const itemId = itemData.id || itemData.item_id;
+                    // Double-check itemId is valid - this should never happen due to filter, but be defensive
+                    if (!itemId || typeof itemId !== "string" || itemId.trim() === "") {
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid return item: item_id is required but got '${itemId}'`);
+                    }
+                    return {
+                        id: itemId,
+                        quantity: Number(itemData.quantity || 0),
+                        reason: itemData.reason_id || itemData.reason, // Handle both reason_id and reason
+                        variant_id: itemData.variant_id, // Preserve variant_id for safe ID mapping
+                    };
+                });
             }
             else if (typeof swapData.return_items === "string") {
                 try {
                     const parsed = JSON.parse(swapData.return_items);
                     if (Array.isArray(parsed)) {
-                        returnItems = parsed.map((item) => ({
-                            id: String(item.id || item.item_id || ""),
-                            quantity: Number(item.quantity || 0),
-                            reason: item.reason,
-                        }));
+                        returnItems = parsed
+                            .filter((item) => {
+                            const itemData = item;
+                            const itemId = itemData.id || itemData.item_id;
+                            return !!itemId && typeof itemId === "string" && itemId.trim() !== "" && (itemData.quantity || 0) > 0;
+                        })
+                            .map((item) => {
+                            const itemData = item;
+                            const itemId = itemData.id || itemData.item_id;
+                            // Double-check itemId is valid - this should never happen due to filter, but be defensive
+                            if (!itemId || typeof itemId !== "string" || itemId.trim() === "") {
+                                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid return item: item_id is required but got '${itemId}'`);
+                            }
+                            return {
+                                id: itemId,
+                                quantity: Number(itemData.quantity || 0),
+                                reason: itemData.reason_id || itemData.reason, // Handle both reason_id and reason
+                                variant_id: itemData.variant_id, // Preserve variant_id for safe ID mapping
+                            };
+                        });
                     }
                 }
-                catch {
-                    // Invalid JSON, will throw error below
+                catch (parseError) {
+                    // If it's a MedusaError, re-throw it
+                    if (parseError instanceof utils_1.MedusaError) {
+                        throw parseError;
+                    }
+                    // Otherwise, invalid JSON - will throw error below
                 }
             }
         }
     }
+    // Validate that all return items have valid item_id
+    const invalidItems = returnItems.filter((item) => !item.id || item.id.trim() === "");
+    if (invalidItems.length > 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid return items found: ${invalidItems.length} item(s) missing valid item_id`);
+    }
     if (returnItems.length === 0) {
         throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Swap must have return items");
     }
@@ -77,19 +196,507 @@ exports.createMedusaReturnStep = (0, workflows_sdk_1.createStep)("create-medusa-
     // Create return using Medusa's Order Module
     let returnId;
     if (orderService.createReturn) {
-        // Map SwapItem format (id) to Medusa return format (item_id)
-        const returnItemsForMedusa = returnItems.map((item) => ({
-            item_id: item.id,
-            quantity: item.quantity,
-            reason_id: item.reason, // Assuming reason is the reason_id
-        }));
+        // Map SwapItem format (id) to Medusa return format (id)
+        // Filter out any items with invalid id before mapping
+        const returnItemsForMedusa = returnItems
+            .filter((item) => {
+            const isValid = !!item.id && typeof item.id === "string" && item.id.trim() !== "" && item.quantity > 0;
+            if (!isValid) {
+                console.warn("[Create Medusa Return] Filtering out invalid return item:", {
+                    id: item.id,
+                    quantity: item.quantity,
+                    reason: item.reason,
+                });
+            }
+            return isValid;
+        })
+            .map((item) => {
+            // Double-check id is valid before mapping
+            if (!item.id || item.id.trim() === "") {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid return item: id is required but got '${item.id}'`);
+            }
+            return {
+                id: item.id,
+                quantity: item.quantity,
+                reason_id: item.reason, // Assuming reason is the reason_id
+                variant_id: item.variant_id, // Preserve variant_id for final validation mapping
+            };
+        });
+        if (returnItemsForMedusa.length === 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "No valid return items found. All items must have a valid id.");
+        }
+        // Validate that all ids exist in the order
+        try {
+            const remoteQuery = container.resolve(utils_2.ContainerRegistrationKeys.REMOTE_QUERY);
+            const orderQuery = (0, utils_2.remoteQueryObjectFromString)({
+                entryPoint: "order",
+                fields: ["id", "items.*", "items.variant_id"], // Use items.* to get all item fields including variant_id
+                filters: {
+                    id: [swapData.order_id],
+                },
+            });
+            const orders = await remoteQuery(orderQuery);
+            const orderArray = Array.isArray(orders) ? orders : orders ? [orders] : [];
+            // Find the correct order (in case multiple orders are returned)
+            let order = orderArray.find((o) => {
+                const orderData = o;
+                return orderData.id === swapData.order_id;
+            });
+            // Fallback to first order if not found (for backwards compatibility)
+            if (!order && orderArray.length > 0) {
+                order = orderArray[0];
+                console.warn("[Create Medusa Return] Order ID mismatch - using first order from results:", {
+                    requested_order_id: swapData.order_id,
+                    first_order_id: orderArray[0].id,
+                });
+            }
+            if (!order) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Order ${swapData.order_id} not found`);
+            }
+            // Verify we got the correct order
+            const orderId = order.id;
+            if (orderId !== swapData.order_id) {
+                console.error("[Create Medusa Return] CRITICAL: Order ID mismatch:", {
+                    requested_order_id: swapData.order_id,
+                    actual_order_id: orderId,
+                    swap_id: swap_id,
+                });
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order ID mismatch: requested ${swapData.order_id} but got ${orderId}`);
+            }
+            if (!order.items || order.items.length === 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order ${swapData.order_id} has no items`);
+            }
+            // Log order items for debugging
+            console.log("[Create Medusa Return] Order items retrieved:", {
+                order_id: swapData.order_id,
+                items_count: order.items.length,
+                item_ids: order.items.map((item) => item.id),
+                items: order.items.map((item) => ({
+                    id: item.id,
+                    variant_id: item.variant_id,
+                    quantity: item.quantity,
+                })),
+            });
+            // Log return items we're trying to match
+            console.log("[Create Medusa Return] Return items to match:", {
+                return_items_count: returnItems.length,
+                return_items: returnItems.map((item) => ({
+                    id: item.id,
+                    quantity: item.quantity,
+                    reason: item.reason,
+                })),
+            });
+            const orderItemIds = new Set(order.items.map((item) => item.id));
+            const orderItemsMap = new Map(order.items.map((item) => [item.id, item]));
+            // Create a map of variant_id to order item for fallback matching
+            const variantToItemMap = new Map();
+            order.items.forEach((item) => {
+                const itemData = item;
+                if (itemData.variant_id) {
+                    // If multiple items have same variant_id, keep the first one
+                    if (!variantToItemMap.has(itemData.variant_id)) {
+                        variantToItemMap.set(itemData.variant_id, itemData);
+                    }
+                }
+            });
+            // Check for invalid ids and try to map them to current item ids
+            const itemsToUpdate = [];
+            const invalidItemIds = [];
+            returnItemsForMedusa.forEach((returnItem, index) => {
+                const itemId = returnItem.id;
+                // Log what we're checking
+                console.log("[Create Medusa Return] Checking return item ID:", {
+                    index,
+                    item_id: itemId,
+                    exists_in_order: orderItemIds.has(itemId),
+                    order_item_ids: Array.from(orderItemIds),
+                    return_item: returnItem,
+                });
+                // If id exists in order, it's valid - don't map it
+                if (orderItemIds.has(itemId)) {
+                    console.log("[Create Medusa Return] Item ID exists in order, no mapping needed:", itemId);
+                    return;
+                }
+                console.warn("[Create Medusa Return] Item ID NOT found in order, attempting to map:", {
+                    item_id: itemId,
+                    order_item_ids: Array.from(orderItemIds),
+                });
+                // Try to find matching item by variant_id from swap data
+                // The variant_id should be stored in return_items during swap creation (from validate-swap-items-step)
+                const swapReturnItem = returnItems.find((ri) => ri.id === itemId);
+                let variantId;
+                // Get variant_id from stored return_items (enriched during swap creation)
+                if (swapReturnItem) {
+                    variantId = swapReturnItem.variant_id;
+                    console.log("[Create Medusa Return] Found variant_id from stored return_items:", {
+                        item_id: itemId,
+                        variant_id: variantId,
+                        has_variant_id: !!variantId,
+                    });
+                }
+                // Fallback: If variant_id not stored, try to get it from current order item
+                // This handles legacy swaps created before variant_id was stored
+                if (!variantId) {
+                    const orderItemWithId = order.items?.find((item) => item.id === itemId);
+                    if (orderItemWithId) {
+                        variantId = orderItemWithId.variant_id;
+                        console.log("[Create Medusa Return] Fallback: Found variant_id from current order item:", {
+                            item_id: itemId,
+                            variant_id: variantId,
+                            note: "This is a legacy swap without stored variant_id",
+                        });
+                    }
+                }
+                // If we have variant_id, try to match by variant_id (safe mapping)
+                if (variantId && variantToItemMap.has(variantId)) {
+                    const matchingItem = variantToItemMap.get(variantId);
+                    itemsToUpdate.push({
+                        index,
+                        oldItemId: itemId,
+                        newItemId: matchingItem.id,
+                    });
+                    console.log("[Create Medusa Return] Successfully mapping stale id to current by variant_id:", {
+                        old_id: itemId,
+                        new_id: matchingItem.id,
+                        variant_id: variantId,
+                        note: "Safe mapping using stored variant_id from swap creation",
+                    });
+                }
+                else if (variantId) {
+                    // We have variant_id but it doesn't exist in current order items
+                    // This means the variant was removed from the order
+                    console.error("[Create Medusa Return] Cannot map - variant_id not found in current order:", {
+                        item_id: itemId,
+                        variant_id: variantId,
+                        order_variant_ids: Array.from(variantToItemMap.keys()),
+                        note: "The variant may have been removed from the order",
+                    });
+                    invalidItemIds.push(itemId);
+                }
+                else {
+                    // CRITICAL: Don't guess! Only map if we can match by variant_id
+                    // Quantity-based and single-item matching is too risky and can map to wrong items
+                    // If the ID doesn't exist and we don't have variant_id, we can't safely map it
+                    console.error("[Create Medusa Return] Cannot map stale ID - variant_id not available:", {
+                        item_id: itemId,
+                        return_item: returnItem,
+                        swap_return_item: swapReturnItem,
+                        order_item_ids: Array.from(orderItemIds),
+                        note: "ID mapping requires variant_id to ensure correct matching. This swap was likely created before variant_id storage was implemented.",
+                    });
+                    invalidItemIds.push(itemId);
+                }
+            });
+            // Update returnItemsForMedusa with correct ids
+            if (itemsToUpdate.length > 0) {
+                console.log("[Create Medusa Return] Updating stale ids:", {
+                    updates: itemsToUpdate,
+                    returnItemsForMedusa_before: returnItemsForMedusa.map((item) => ({
+                        id: item.id,
+                        quantity: item.quantity,
+                    })),
+                });
+                itemsToUpdate.forEach(({ index, newItemId }) => {
+                    const oldItemId = returnItemsForMedusa[index].id;
+                    returnItemsForMedusa[index].id = newItemId;
+                    console.log("[Create Medusa Return] Updated item at index:", {
+                        index,
+                        old_id: oldItemId,
+                        new_id: newItemId,
+                        item_after_update: returnItemsForMedusa[index],
+                    });
+                });
+                console.log("[Create Medusa Return] returnItemsForMedusa after update:", {
+                    returnItemsForMedusa: returnItemsForMedusa.map((item) => ({
+                        id: item.id,
+                        quantity: item.quantity,
+                    })),
+                });
+            }
+            // If there are still invalid ids after mapping, throw error
+            if (invalidItemIds.length > 0) {
+                console.error("[Create Medusa Return] Invalid ids detected (could not map):", {
+                    invalidItemIds,
+                    orderItemIds: Array.from(orderItemIds),
+                    returnItemsForMedusa,
+                    original_return_items: returnItems,
+                    orderItems: order.items.map((item) => ({
+                        id: item.id,
+                        variant_id: item.variant_id,
+                        quantity: item.quantity,
+                    })),
+                    swap_id: swap_id,
+                    order_id: swapData.order_id,
+                });
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ID${invalidItemIds.length > 1 ? "s" : ""} "${invalidItemIds.join('", "')}" not found in order ${swapData.order_id} and could not be safely mapped. ` +
+                    `The order may have been modified since the swap was created. ` +
+                    `Available order item IDs: ${Array.from(orderItemIds).join(", ")}. ` +
+                    `To fix this, the swap's return_items should include variant_id for each item to enable safe ID mapping.`);
+            }
+        }
+        catch (validationError) {
+            // If it's a MedusaError, re-throw it (don't catch and continue)
+            if (validationError instanceof utils_1.MedusaError) {
+                throw validationError;
+            }
+            // For other errors (like query failures), log and let Medusa handle validation
+            console.warn("[Create Medusa Return] Failed to validate ids against order:", validationError);
+        }
+        // Final safety check - ensure no items have undefined id
+        const itemsWithUndefinedId = returnItemsForMedusa.filter((item) => {
+            const hasUndefinedId = item.id === undefined || item.id === null || item.id === "";
+            if (hasUndefinedId) {
+                console.error("[Create Medusa Return] Item with undefined id detected:", {
+                    item,
+                    id: item.id,
+                    id_type: typeof item.id,
+                });
+            }
+            return hasUndefinedId;
+        });
+        if (itemsWithUndefinedId.length > 0) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot create return: ${itemsWithUndefinedId.length} item(s) have undefined or null id. Items: ${JSON.stringify(itemsWithUndefinedId)}`);
+        }
+        // Log what we're about to send to Medusa for debugging
+        console.log("[Create Medusa Return] Creating return with items:", {
+            order_id: swapData.order_id,
+            items_count: returnItemsForMedusa.length,
+            items: returnItemsForMedusa.map((item) => ({
+                id: item.id,
+                quantity: item.quantity,
+                reason_id: item.reason_id,
+            })),
+        });
         // Use swap's location_id as fallback if not provided in input
         const finalLocationId = return_location_id || swapData.return_location_id;
-        const medusaReturn = await orderService.createReturn({
+        // Final validation before createReturn call - ensure all items have valid id and quantity
+        const invalidItemsBeforeCreate = returnItemsForMedusa.filter((item) => !item.id || item.id === undefined || item.id === null || item.id === "" || item.quantity <= 0);
+        if (invalidItemsBeforeCreate.length > 0) {
+            console.error("[Create Medusa Return] CRITICAL: Invalid items detected before createReturn:", {
+                invalidItems: invalidItemsBeforeCreate,
+                allItems: returnItemsForMedusa,
+            });
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot create return: ${invalidItemsBeforeCreate.length} item(s) have invalid id or quantity`);
+        }
+        // Create plain objects with only required properties
+        // Use id instead of item_id as Medusa expects id to reference order line items
+        const itemsForCreateReturn = returnItemsForMedusa.map((item) => {
+            const returnItem = {
+                id: String(item.id).trim(),
+                quantity: Number(item.quantity),
+            };
+            if (item.reason_id && String(item.reason_id).trim() !== "") {
+                returnItem.reason_id = String(item.reason_id).trim();
+            }
+            return returnItem;
+        });
+        console.log("[Create Medusa Return] Final items structure for createReturn:", {
+            items: itemsForCreateReturn,
+            items_json: JSON.stringify(itemsForCreateReturn),
+            items_count: itemsForCreateReturn.length,
+        });
+        // Final validation: Re-query order to ensure IDs are still valid
+        // This catches any race conditions where order items changed between validation and createReturn
+        try {
+            const remoteQuery = container.resolve(utils_2.ContainerRegistrationKeys.REMOTE_QUERY);
+            const finalOrderQuery = (0, utils_2.remoteQueryObjectFromString)({
+                entryPoint: "order",
+                fields: ["id", "items.id", "items.variant_id", "items.quantity"],
+                filters: {
+                    id: [swapData.order_id],
+                },
+            });
+            const finalOrders = await remoteQuery(finalOrderQuery);
+            const finalOrderArray = Array.isArray(finalOrders) ? finalOrders : finalOrders ? [finalOrders] : [];
+            const finalOrder = finalOrderArray[0];
+            if (finalOrder && finalOrder.items) {
+                const finalOrderItemIds = new Set(finalOrder.items.map((item) => item.id));
+                // Create variant_id map for final order items
+                const finalVariantToItemMap = new Map();
+                finalOrder.items.forEach((item) => {
+                    const itemData = item;
+                    if (itemData.variant_id) {
+                        // If multiple items have same variant_id, keep the first one
+                        if (!finalVariantToItemMap.has(itemData.variant_id)) {
+                            finalVariantToItemMap.set(itemData.variant_id, itemData);
+                        }
+                    }
+                });
+                const invalidFinalIds = itemsForCreateReturn
+                    .map((item) => item.id)
+                    .filter((id) => !finalOrderItemIds.has(id));
+                // Enhanced logging for comparison
+                console.log("[Create Medusa Return] Final validation - Order vs Return Items:", {
+                    order_id: swapData.order_id,
+                    order_item_ids: Array.from(finalOrderItemIds),
+                    order_items: finalOrder.items.map((item) => ({
+                        id: item.id,
+                        variant_id: item.variant_id,
+                        quantity: item.quantity,
+                    })),
+                    return_items_being_sent: itemsForCreateReturn.map((item) => ({
+                        id: item.id,
+                        quantity: item.quantity,
+                    })),
+                    swap_return_items_original: returnItems.map((item) => ({
+                        id: item.id,
+                        quantity: item.quantity,
+                        variant_id: item.variant_id,
+                    })),
+                    invalid_ids: invalidFinalIds,
+                });
+                // If there are invalid IDs, try to map them using variant_id
+                if (invalidFinalIds.length > 0) {
+                    console.warn("[Create Medusa Return] IDs changed between queries, attempting to map using variant_id:", {
+                        invalid_ids: invalidFinalIds,
+                        valid_order_item_ids: Array.from(finalOrderItemIds),
+                    });
+                    const finalItemsToUpdate = [];
+                    // Try to map each invalid ID using variant_id
+                    // Use returnItemsForMedusa to get variant_id (indices match since itemsForCreateReturn is created from returnItemsForMedusa)
+                    itemsForCreateReturn.forEach((returnItem, index) => {
+                        if (!finalOrderItemIds.has(returnItem.id)) {
+                            // Get variant_id from returnItemsForMedusa (indices match)
+                            const swapReturnItem = returnItemsForMedusa[index];
+                            const variantId = swapReturnItem.variant_id;
+                            if (variantId && finalVariantToItemMap.has(variantId)) {
+                                const matchingItem = finalVariantToItemMap.get(variantId);
+                                finalItemsToUpdate.push({
+                                    index,
+                                    oldItemId: returnItem.id,
+                                    newItemId: matchingItem.id,
+                                });
+                                console.log("[Create Medusa Return] Final validation mapping by variant_id:", {
+                                    old_id: returnItem.id,
+                                    new_id: matchingItem.id,
+                                    variant_id: variantId,
+                                    note: "Order items changed between queries, using variant_id to map",
+                                });
+                            }
+                            else if (!variantId) {
+                                console.warn("[Create Medusa Return] Cannot map - variant_id not available:", {
+                                    item_id: returnItem.id,
+                                    index,
+                                    swap_return_item: swapReturnItem,
+                                });
+                            }
+                            else {
+                                console.warn("[Create Medusa Return] Cannot map - variant_id not found in current order:", {
+                                    item_id: returnItem.id,
+                                    variant_id: variantId,
+                                    available_variant_ids: Array.from(finalVariantToItemMap.keys()),
+                                });
+                            }
+                        }
+                    });
+                    // Update itemsForCreateReturn with mapped IDs
+                    if (finalItemsToUpdate.length > 0) {
+                        console.log("[Create Medusa Return] Updating itemsForCreateReturn with mapped IDs:", {
+                            updates: finalItemsToUpdate,
+                            items_before: itemsForCreateReturn.map((item) => ({ id: item.id, quantity: item.quantity })),
+                        });
+                        finalItemsToUpdate.forEach(({ index, newItemId }) => {
+                            itemsForCreateReturn[index].id = newItemId;
+                        });
+                        console.log("[Create Medusa Return] Items after mapping:", {
+                            items_after: itemsForCreateReturn.map((item) => ({ id: item.id, quantity: item.quantity })),
+                        });
+                    }
+                    // Check again after mapping
+                    const remainingInvalidIds = itemsForCreateReturn
+                        .map((item) => item.id)
+                        .filter((id) => !finalOrderItemIds.has(id));
+                    if (remainingInvalidIds.length > 0) {
+                        // Check if variant_id mismatch is the issue
+                        const variantMismatches = [];
+                        remainingInvalidIds.forEach((invalidId) => {
+                            const swapReturnItem = returnItems.find((ri) => ri.id === invalidId);
+                            const swapVariantId = swapReturnItem?.variant_id;
+                            if (swapVariantId) {
+                                variantMismatches.push({
+                                    item_id: invalidId,
+                                    swap_variant_id: swapVariantId,
+                                    order_variant_ids: Array.from(finalVariantToItemMap.keys()),
+                                });
+                            }
+                        });
+                        console.error("[Create Medusa Return] CRITICAL: Invalid IDs detected after mapping:", {
+                            invalid_ids: remainingInvalidIds,
+                            valid_order_item_ids: Array.from(finalOrderItemIds),
+                            items_being_sent: itemsForCreateReturn,
+                            swap_return_items_original: returnItems,
+                            swap_id: swap_id,
+                            variant_mismatches: variantMismatches,
+                        });
+                        // Provide clearer error message if variant mismatch detected
+                        if (variantMismatches.length > 0) {
+                            const mismatch = variantMismatches[0];
+                            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Cannot approve swap: The order item with ID "${remainingInvalidIds[0]}" (variant: ${mismatch.swap_variant_id}) no longer exists in order ${swapData.order_id}. ` +
+                                `The order item was replaced with a different product variant (${mismatch.order_variant_ids.join(", ") || "unknown"}). ` +
+                                `You cannot return an item that has been replaced with a different product. Please cancel this swap and create a new one for the current order items.`);
+                        }
+                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ID${remainingInvalidIds.length > 1 ? "s" : ""} "${remainingInvalidIds.join('", "')}" not found in order ${swapData.order_id} and could not be mapped. Available item IDs: ${Array.from(finalOrderItemIds).join(", ")}`);
+                    }
+                }
+            }
+        }
+        catch (finalValidationError) {
+            // If it's a MedusaError we created, re-throw it
+            if (finalValidationError instanceof utils_1.MedusaError) {
+                throw finalValidationError;
+            }
+            // Otherwise, log warning but continue - Medusa will validate
+            console.warn("[Create Medusa Return] Final validation query failed, proceeding:", finalValidationError);
+        }
+        // Log exactly what we're sending to Medusa before the call
+        console.log("[Create Medusa Return] About to call orderService.createReturn:", {
             order_id: swapData.order_id,
-            items: returnItemsForMedusa,
             location_id: finalLocationId,
+            items_count: itemsForCreateReturn.length,
+            items: itemsForCreateReturn,
+            item_ids: itemsForCreateReturn.map((item) => item.id),
         });
+        // Call createReturn with simplified structure
+        let medusaReturn;
+        try {
+            medusaReturn = await orderService.createReturn({
+                order_id: swapData.order_id,
+                items: itemsForCreateReturn,
+                location_id: finalLocationId,
+            });
+        }
+        catch (createReturnError) {
+            // Enhanced error logging for Medusa's createReturn errors
+            const errorMessage = createReturnError instanceof Error ? createReturnError.message : String(createReturnError);
+            console.error("[Create Medusa Return] Error from orderService.createReturn:", {
+                error: createReturnError,
+                error_message: errorMessage,
+                error_type: createReturnError instanceof Error ? createReturnError.constructor.name : typeof createReturnError,
+                order_id: swapData.order_id,
+                items_sent: itemsForCreateReturn,
+                item_ids_sent: itemsForCreateReturn.map((item) => item.id),
+                location_id: finalLocationId,
+                swap_return_items_original: returnItems,
+                swap_id: swap_id,
+            });
+            // If the error message contains "Item ID" and "not found", enhance it with more context
+            if (errorMessage.includes("Item ID") && errorMessage.includes("not found")) {
+                // Try to extract the invalid ID from the error message
+                const idMatch = errorMessage.match(/Item ID\s+"([^"]+)"/i);
+                const invalidId = idMatch ? idMatch[1] : null;
+                if (invalidId) {
+                    // Check if this ID was in our original return_items
+                    const wasInOriginal = returnItems.some((ri) => ri.id === invalidId);
+                    throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ID "${invalidId}" not found in order ${swapData.order_id}. ` +
+                        `This ID ${wasInOriginal ? "was in the swap's return_items" : "was not in the swap's return_items"}. ` +
+                        `It may be a stale order item ID (the order may have been modified since the swap was created). ` +
+                        `Swap ID: ${swap_id}. ` +
+                        `Original return_items: ${JSON.stringify(returnItems)}. ` +
+                        `Items being sent to createReturn: ${JSON.stringify(itemsForCreateReturn.map((item) => ({ id: item.id, quantity: item.quantity })))}`);
+                }
+            }
+            throw createReturnError;
+        }
         returnId = medusaReturn.id;
         // Use swap's return_shipping_method_id as fallback if not provided in input
         const finalReturnShippingMethodId = return_shipping_method_id || swapData.return_shipping_method_id;
@@ -148,4 +755,4 @@ exports.createMedusaReturnStep = (0, workflows_sdk_1.createStep)("create-medusa-
         swap: finalSwap || swap,
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-medusa-return-step.js","sourceRoot":"","sources":["../../../../../../src/workflows/steps/swap/create-medusa-return-step.ts"],"names":[],"mappings":"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"}