order-management 0.0.20 → 0.0.22

package/.medusa/server/src/modules/swap/service.js

@@ -8,28 +8,178 @@ class SwapService extends (0, utils_1.MedusaService)({ Swap: swap_1.Swap }) {
         this.manager_ = container.manager;
         this.logger_ = container.logger;
     }
+    /**
+     * Helper function to parse and normalize swap items arrays
+     * Handles both array format and JSONB format from database
+     */
+    parseSwapItems(items) {
+        if (!items)
+            return [];
+        if (Array.isArray(items)) {
+            return items.map((item) => ({
+                id: String(item.id || item.item_id || ""),
+                quantity: Number(item.quantity || 0),
+                reason: item.reason ? String(item.reason) : undefined,
+            }));
+        }
+        // If it's a JSON string, parse it
+        if (typeof items === "string") {
+            try {
+                const parsed = JSON.parse(items);
+                return Array.isArray(parsed) ? this.parseSwapItems(parsed) : [];
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    }
+    /**
+     * Helper function to parse and normalize new items arrays
+     */
+    parseNewItems(items) {
+        if (!items)
+            return [];
+        if (Array.isArray(items)) {
+            return items.map((item) => ({
+                variant_id: String(item.variant_id || ""),
+                quantity: Number(item.quantity || 0),
+            }));
+        }
+        // If it's a JSON string, parse it
+        if (typeof items === "string") {
+            try {
+                const parsed = JSON.parse(items);
+                return Array.isArray(parsed) ? this.parseNewItems(parsed) : [];
+            }
+            catch {
+                return [];
+            }
+        }
+        return [];
+    }
+    /**
+     * Helper function to normalize and compare swap items arrays
+     */
+    normalizeSwapItems(items) {
+        return JSON.stringify(items
+            .map((item) => ({ id: item.id, quantity: item.quantity }))
+            .sort((a, b) => a.id.localeCompare(b.id)));
+    }
+    /**
+     * Helper function to normalize and compare new items arrays
+     */
+    normalizeNewItems(items) {
+        return JSON.stringify(items
+            .map((item) => ({ variant_id: item.variant_id, quantity: item.quantity }))
+            .sort((a, b) => a.variant_id.localeCompare(b.variant_id)));
+    }
+    /**
+     * Check for duplicate swaps with the same return_items and new_items
+     * This is called both in validateEligibility and createSwap to prevent race conditions
+     *
+     * Note: Uses pagination to handle orders with many swaps.
+     * If an order has more than 1000 swaps, we check in batches.
+     */
+    async checkForDuplicateSwap(orderId, returnItems, newItems) {
+        // Check for ALL existing swaps for the same order (not just pending ones)
+        // This prevents creating duplicate swap requests regardless of status
+        // Use pagination to handle orders with many swaps
+        const batchSize = 1000;
+        let skip = 0;
+        let hasMore = true;
+        const allSwapsArray = [];
+        while (hasMore) {
+            const batch = await this.listSwaps({
+                order_id: orderId,
+            }, {
+                take: batchSize,
+                skip,
+            });
+            const batchArray = Array.isArray(batch) ? batch : batch ? [batch] : [];
+            allSwapsArray.push(...batchArray);
+            // If we got fewer results than batchSize, we've reached the end
+            hasMore = batchArray.length === batchSize;
+            skip += batchSize;
+        }
+        const swapsArray = allSwapsArray;
+        // Normalize current swap items for comparison
+        const currentReturnItemsNormalized = this.normalizeSwapItems(returnItems);
+        const currentNewItemsNormalized = this.normalizeNewItems(newItems);
+        this.logger_?.info(`Checking for duplicate swap: order_id=${orderId}, existing_swaps=${swapsArray.length}`);
+        // Check each existing swap for exact duplicates
+        for (const existingSwap of swapsArray) {
+            const swapData = existingSwap;
+            // Parse the stored data (might be JSONB format)
+            const existingReturnItems = this.parseSwapItems(swapData.return_items);
+            const existingNewItems = this.parseNewItems(swapData.new_items);
+            // Skip if no items found (shouldn't happen, but defensive)
+            if (existingReturnItems.length === 0 || existingNewItems.length === 0) {
+                continue;
+            }
+            // Normalize existing swap items for comparison
+            const existingReturnItemsNormalized = this.normalizeSwapItems(existingReturnItems);
+            const existingNewItemsNormalized = this.normalizeNewItems(existingNewItems);
+            // Check for exact match (both return_items AND new_items must match)
+            if (currentReturnItemsNormalized === existingReturnItemsNormalized &&
+                currentNewItemsNormalized === existingNewItemsNormalized) {
+                const status = swapData.status || "unknown";
+                this.logger_?.warn(`Duplicate swap detected: order_id=${orderId}, existing_swap_id=${swapData.id}, status=${status}`);
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `A swap request with the same return items and new items already exists for this order (ID: ${swapData.id}, status: ${status}). Please use the existing swap request instead.`);
+            }
+        }
+    }
     async createSwap(input) {
-        const { order_id, return_items, new_items, reason, note } = input;
+        const { order_id, customer_id, return_items, new_items, difference_due, reason, note } = input;
+        if (!customer_id) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Customer ID is required");
+        }
         if (!return_items || return_items.length === 0) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Return items are required");
         }
         if (!new_items || new_items.length === 0) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "New items are required");
         }
+        // CRITICAL: Check for duplicates BEFORE creating to prevent race conditions
+        // This is called again here even though validateEligibility also checks,
+        // because there's a time window between validation and creation where
+        // another request could create a duplicate
+        // 
+        // Note: This check reduces but doesn't eliminate race conditions.
+        // For complete protection, consider:
+        // 1. Database-level unique constraint on (order_id, return_items_hash, new_items_hash)
+        // 2. Application-level distributed locking (Redis, etc.)
+        // 3. Optimistic locking with version field
+        this.logger_?.info(`Creating swap: order_id=${order_id}, customer_id=${customer_id}, checking for duplicates before creation`);
+        try {
+            await this.checkForDuplicateSwap(order_id, return_items, new_items);
+            this.logger_?.info(`No duplicates found, proceeding with swap creation: order_id=${order_id}`);
+        }
+        catch (duplicateError) {
+            // Re-throw duplicate errors with more context
+            if (duplicateError instanceof utils_1.MedusaError && duplicateError.type === utils_1.MedusaError.Types.DUPLICATE_ERROR) {
+                throw duplicateError;
+            }
+            // If it's a different error, wrap it
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.DUPLICATE_ERROR, `Duplicate swap detected for order ${order_id}. This may be due to concurrent requests.`);
+        }
         const swap = await this.createSwaps({
             order_id,
+            customer_id,
             status: "requested",
             return_items: return_items,
             new_items: new_items,
-            difference_due: 0, // Will be calculated later
+            difference_due: difference_due ?? 0, // Use provided difference_due or default to 0
             reason: reason || null,
             note: note || null,
             metadata: {
                 created_at: new Date().toISOString(),
+                customer_id, // Store in metadata for redundancy and audit trail
                 status_history: [
                     {
                         status: "requested",
                         timestamp: new Date().toISOString(),
+                        customer_id,
                     },
                 ],
             },
@@ -113,15 +263,9 @@ class SwapService extends (0, utils_1.MedusaService)({ Swap: swap_1.Swap }) {
         const currentStatus = swapData.status;
         // Validate status transition
         const validTransitions = {
-            requested: ["approved", "rejected", "cancelled"],
-            approved: ["return_started", "cancelled"],
-            return_started: ["return_shipped", "cancelled"],
-            return_shipped: ["return_received", "cancelled"],
-            return_received: ["new_items_shipped", "cancelled"],
-            new_items_shipped: ["completed", "cancelled"],
+            requested: ["approved", "rejected"],
+            approved: [], // Terminal state (exchange created separately)
             rejected: [], // Terminal state
-            completed: [], // Terminal state
-            cancelled: [], // Terminal state
         };
         const allowedTransitions = validTransitions[currentStatus] || [];
         if (!allowedTransitions.includes(status)) {
@@ -159,33 +303,115 @@ class SwapService extends (0, utils_1.MedusaService)({ Swap: swap_1.Swap }) {
         // For now, return stored value or 0 - this will be implemented in workflow step
         return swapData.difference_due || 0;
     }
-    async validateEligibility(orderId, returnItems) {
-        // Check for existing pending swaps for the same order
-        const existingSwaps = await this.listSwaps({
-            order_id: orderId,
-            status: ["requested", "approved", "return_started"],
-        }, {
-            take: 100,
+    /**
+     * Rollback orphaned return - removes return_id from swap when exchange creation fails
+     * This is used when exchange creation fails after return creation
+     */
+    async rollbackReturn(swapId, returnId, reason) {
+        const swap = await this.retrieveSwap(swapId);
+        const swapData = swap;
+        // Only rollback if return_id matches
+        if (swapData.return_id !== returnId) {
+            // Return already changed or doesn't match
+            return swap;
+        }
+        const swapMetadata = swapData.metadata || {};
+        const medusaIntegration = swapMetadata.medusa_integration || {};
+        const rollbackHistory = swapMetadata.rollback_history || [];
+        // Remove return_id from swap and log rollback
+        const updatedSwap = await this.updateSwaps({
+            selector: { id: swapId },
+            data: {
+                return_id: null,
+                metadata: {
+                    ...swapMetadata,
+                    medusa_integration: {
+                        ...medusaIntegration,
+                        return_id: null,
+                        return_rollback_at: new Date().toISOString(),
+                        return_rollback_reason: reason,
+                    },
+                    rollback_history: [
+                        ...rollbackHistory,
+                        {
+                            action: "rollback_return",
+                            return_id: returnId,
+                            reason,
+                            timestamp: new Date().toISOString(),
+                        },
+                    ],
+                },
+            },
         });
-        const swapsArray = Array.isArray(existingSwaps) ? existingSwaps : existingSwaps ? [existingSwaps] : [];
-        // Check if any return items overlap with existing swaps
-        for (const existingSwap of swapsArray) {
+        return Array.isArray(updatedSwap) ? updatedSwap[0] : updatedSwap;
+    }
+    async validateEligibility(orderId, returnItems, newItems, orderItems) {
+        // 1. Check for exact duplicate swaps (same return_items + new_items)
+        // This uses the same logic as createSwap to ensure consistency
+        await this.checkForDuplicateSwap(orderId, returnItems, newItems);
+        // 2. Check quantity overlap for return items in PENDING swaps only
+        // Calculate total requested quantity per item across all pending swaps
+        // Use pagination to handle orders with many swaps
+        const batchSize = 1000;
+        let skip = 0;
+        let hasMore = true;
+        const allSwapsArray = [];
+        while (hasMore) {
+            const batch = await this.listSwaps({
+                order_id: orderId,
+            }, {
+                take: batchSize,
+                skip,
+            });
+            const batchArray = Array.isArray(batch) ? batch : batch ? [batch] : [];
+            allSwapsArray.push(...batchArray);
+            // If we got fewer results than batchSize, we've reached the end
+            hasMore = batchArray.length === batchSize;
+            skip += batchSize;
+        }
+        const swapsArray = allSwapsArray;
+        const pendingSwaps = swapsArray.filter((swap) => {
+            const swapData = swap;
+            const status = swapData.status || "";
+            return ["requested", "approved", "return_started"].includes(status);
+        });
+        const requestedQuantities = {};
+        // Sum quantities from existing pending swaps (parse the data first)
+        for (const existingSwap of pendingSwaps) {
             const swapData = existingSwap;
-            const existingReturnItems = swapData.return_items;
-            if (existingReturnItems) {
-                for (const returnItem of returnItems) {
-                    const hasOverlap = existingReturnItems.some((existing) => existing.id === returnItem.id && existing.quantity > 0);
-                    if (hasOverlap) {
-                        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ${returnItem.id} is already part of a pending swap for this order`);
-                    }
+            const existingReturnItems = this.parseSwapItems(swapData.return_items);
+            for (const existingItem of existingReturnItems) {
+                if (existingItem.id && existingItem.quantity > 0) {
+                    requestedQuantities[existingItem.id] =
+                        (requestedQuantities[existingItem.id] || 0) + existingItem.quantity;
                 }
             }
         }
+        // Add current request quantities and validate against order quantities
+        for (const returnItem of returnItems) {
+            if (!returnItem.id || returnItem.quantity <= 0) {
+                continue;
+            }
+            const orderItem = orderItems.find((item) => item.id === returnItem.id);
+            if (!orderItem) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Return item ${returnItem.id} not found in order`);
+            }
+            // STRICT CHECK: Prevent any item from being in multiple pending swaps
+            // This ensures no duplicate swap requests for the same item
+            if (requestedQuantities[returnItem.id] > 0) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ${returnItem.id} is already part of a pending swap for this order and cannot be included in another swap request`);
+            }
+            // Also validate quantity doesn't exceed available
+            if (returnItem.quantity > orderItem.quantity) {
+                throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Item ${returnItem.id}: Requested quantity (${returnItem.quantity}) exceeds available quantity (${orderItem.quantity}) in order`);
+            }
+        }
     }
     async checkRateLimit(customerId, orderId) {
         // Check for existing swaps by this customer for this order
         const existingSwaps = await this.listSwaps({
             order_id: orderId,
+            customer_id: customerId,
         }, {
             take: 100,
         });
@@ -195,16 +421,17 @@ class SwapService extends (0, utils_1.MedusaService)({ Swap: swap_1.Swap }) {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Maximum ${maxSwapsPerOrder} swaps allowed per order`);
         }
         // Check customer's total swap count (across all orders)
-        const customerSwaps = await this.listSwaps({}, {
-            take: 1000,
+        // Now we can filter directly by customer_id without joining with orders
+        const customerSwaps = await this.listSwaps({
+            customer_id: customerId,
+        }, {
+            take: 1000, // Reasonable limit for rate limiting check
         });
         const customerSwapsArray = Array.isArray(customerSwaps)
             ? customerSwaps
             : customerSwaps
                 ? [customerSwaps]
                 : [];
-        // Filter by customer (would need to join with order, simplified here)
-        // In a real implementation, you'd query orders with customer_id and then swaps
         const maxSwapsPerCustomer = 20; // Configurable limit
         const customerSwapCount = customerSwapsArray.length;
         if (customerSwapCount >= maxSwapsPerCustomer) {
@@ -221,4 +448,4 @@ class SwapService extends (0, utils_1.MedusaService)({ Swap: swap_1.Swap }) {
     }
 }
 exports.default = SwapService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/swap/service.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../../../src/modules/swap/service.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/subscribers/exchange-created.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = exchangeCreatedHandler;
+const utils_1 = require("@medusajs/framework/utils");
+const swap_1 = require("../modules/swap");
+/**
+ * Subscriber handler for exchange created events
+ * Automatically links exchanges created by admin to approved swaps
+ *
+ * When an exchange is created, this subscriber:
+ * 1. Finds the swap with matching order_id and status "approved" without exchange_id
+ * 2. Links the exchange to the swap by updating exchange_id field
+ * 3. Stores linking timestamp in metadata
+ */
+async function exchangeCreatedHandler({ event: { data }, container, }) {
+    const startTime = Date.now();
+    let retryCount = 0;
+    const maxRetries = 3;
+    const retryDelay = 1000; // 1 second base delay
+    // Log event received for verification
+    console.log("[Exchange Created Subscriber] Event received:", {
+        event_name: "exchange.created",
+        exchange_id: data.id,
+        order_id: data.order_id,
+        timestamp: new Date().toISOString(),
+    });
+    const executeWithRetry = async () => {
+        try {
+            const exchangeId = data.id;
+            const orderId = data.order_id;
+            if (!exchangeId) {
+                console.error("[Exchange Created Subscriber] No exchange ID found in event data");
+                return;
+            }
+            if (!orderId) {
+                console.debug("[Exchange Created Subscriber] No order_id in exchange, skipping link");
+                return;
+            }
+            const swapService = container.resolve(swap_1.SWAP_MODULE);
+            const remoteQuery = container.resolve(utils_1.ContainerRegistrationKeys.REMOTE_QUERY);
+            // Validate exchange exists in Medusa before processing
+            try {
+                const exchangeQuery = (0, utils_1.remoteQueryObjectFromString)({
+                    entryPoint: "exchange",
+                    fields: ["id", "order_id"],
+                    filters: {
+                        id: [exchangeId],
+                    },
+                });
+                const exchanges = await remoteQuery(exchangeQuery);
+                const exchangeArray = Array.isArray(exchanges) ? exchanges : exchanges ? [exchanges] : [];
+                const exchange = exchangeArray.find((e) => {
+                    const eData = e;
+                    return eData?.id === exchangeId;
+                });
+                if (!exchange) {
+                    console.warn(`[Exchange Created Subscriber] Exchange ${exchangeId} not found in Medusa, skipping link`);
+                    return;
+                }
+            }
+            catch (validationError) {
+                const validationErrorMessage = validationError instanceof Error ? validationError.message : String(validationError);
+                console.warn(`[Exchange Created Subscriber] Failed to validate exchange ${exchangeId}: ${validationErrorMessage}`);
+                // Continue processing even if validation fails (might be transient)
+            }
+            // Find swap by order_id where status is "approved" and exchange_id is null
+            let swaps;
+            let swap = null;
+            try {
+                swaps = await swapService.listSwaps({
+                    order_id: orderId,
+                    status: "approved",
+                }, { take: 10 });
+                const swapsArray = Array.isArray(swaps) ? swaps : swaps ? [swaps] : [];
+                // Find swap without exchange_id (not yet linked)
+                swap = swapsArray.find((s) => {
+                    const swapData = s;
+                    return !swapData.exchange_id;
+                }) || null;
+            }
+            catch (filterError) {
+                const errorMessage = filterError instanceof Error ? filterError.message : String(filterError);
+                console.warn(`[Exchange Created Subscriber] Failed to find swap: ${errorMessage}`);
+                return;
+            }
+            if (!swap) {
+                // No unlinked approved swap found for this order
+                // This is expected if:
+                // - Exchange was created manually without a swap request
+                // - Swap is not approved yet
+                // - Swap already has an exchange_id
+                console.debug(`[Exchange Created Subscriber] No unlinked approved swap found for order ${orderId} and exchange ${exchangeId}`);
+                return;
+            }
+            const swapData = swap;
+            if (!swapData.id) {
+                console.error("[Exchange Created Subscriber] Swap found but missing ID");
+                return;
+            }
+            // Link exchange to swap
+            const swapMetadata = swapData.metadata || {};
+            const linkingHistory = swapMetadata.exchange_linking_history || [];
+            await swapService.updateSwaps({
+                selector: { id: swapData.id },
+                data: {
+                    exchange_id: exchangeId,
+                    metadata: {
+                        ...swapMetadata,
+                        exchange_linking_history: [
+                            ...linkingHistory,
+                            {
+                                exchange_id: exchangeId,
+                                linked_at: new Date().toISOString(),
+                                linked_by: "exchange_created_subscriber",
+                            },
+                        ],
+                        exchange_linked_at: new Date().toISOString(),
+                    },
+                },
+            });
+            const duration = Date.now() - startTime;
+            console.log(`[Exchange Created Subscriber] Linked exchange ${exchangeId} to swap ${swapData.id}`, {
+                duration_ms: duration,
+                retry_count: retryCount,
+                order_id: orderId,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorStack = error instanceof Error ? error.stack : undefined;
+            // Retry logic with exponential backoff
+            if (retryCount < maxRetries) {
+                retryCount++;
+                const delay = retryDelay * Math.pow(2, retryCount - 1);
+                console.warn(`[Exchange Created Subscriber] Retry ${retryCount}/${maxRetries} after ${delay}ms:`, errorMessage);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+                return executeWithRetry();
+            }
+            console.error("[Exchange Created Subscriber] Error linking exchange to swap (max retries exceeded):", {
+                error: errorMessage,
+                stack: errorStack,
+                retry_count: retryCount,
+                exchange_id: data.id,
+                order_id: data.order_id,
+            });
+            // Don't throw - subscriber errors shouldn't break the exchange flow
+        }
+    };
+    await executeWithRetry();
+}
+/**
+ * Subscriber configuration
+ *
+ * Event Name: "exchange.created"
+ *
+ * This subscriber listens for exchange creation events in Medusa.
+ * When an exchange is created, it automatically links it to an approved swap
+ * if one exists for the same order.
+ *
+ * Event Data Structure Expected:
+ * {
+ *   id: string (exchange ID)
+ *   order_id?: string (order ID)
+ *   [key: string]: unknown (other exchange fields)
+ * }
+ */
+exports.config = {
+    event: "exchange.created",
+};
+//# sourceMappingURL=data:application/json;base64,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