order-management 0.0.1 → 0.0.2

package/.medusa/server/src/api/admin/returns/[id]/retry-refund/route.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const utils_2 = require("@medusajs/framework/utils");
+const process_cod_refund_workflow_1 = __importDefault(require("../../../../../workflows/process-cod-refund-workflow"));
+/**
+ * Helper function to find return by ID
+ * Reused from payment-details route - consider extracting to shared utility
+ */
+async function findReturnById(orderService, returnId) {
+    try {
+        const orders = await orderService.listOrders({});
+        for (const order of orders) {
+            const orderWithReturns = order;
+            const returns = orderWithReturns.returns || [];
+            const returnRecord = returns.find((ret) => ret.id === returnId);
+            if (returnRecord) {
+                return returnRecord;
+            }
+        }
+    }
+    catch (error) {
+        console.error("Error finding return:", error);
+    }
+    return null;
+}
+/**
+ * Admin API endpoint to retry a failed refund
+ *
+ * POST /admin/returns/[id]/retry-refund
+ *
+ * Retries processing a refund for a return that previously failed.
+ * Increments retry_count and attempts payment processing again.
+ */
+const POST = async (req, res) => {
+    const { id: return_id } = req.params;
+    if (!return_id) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Return ID is required");
+    }
+    const orderService = req.scope.resolve(utils_2.Modules.ORDER);
+    // Find return to get order_id
+    const returnRecord = await findReturnById(orderService, return_id);
+    if (!returnRecord) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Return with ID ${return_id} not found`);
+    }
+    const orderId = returnRecord.order_id;
+    if (!orderId) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Return ${return_id} does not have an associated order_id`);
+    }
+    // Execute refund workflow (will handle retry logic internally)
+    try {
+        const { result } = await (0, process_cod_refund_workflow_1.default)(req.scope).run({
+            input: {
+                return_id,
+                order_id: orderId,
+            },
+        });
+        return res.json({
+            success: true,
+            message: "Refund retry initiated successfully",
+            refund_id: result.refund_id,
+            amount: result.amount,
+            currency_code: result.currency_code,
+            order_id: result.order_id,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        // Return error response instead of throwing to provide better API response
+        return res.status(500).json({
+            success: false,
+            message: "Refund retry failed",
+            error: errorMessage,
+            return_id,
+            order_id: orderId,
+        });
+    }
+};
+exports.POST = POST;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/admin/returns/failed-refunds/route.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const utils_2 = require("@medusajs/framework/utils");
+/**
+ * Admin API endpoint to list failed refunds
+ *
+ * GET /admin/returns/failed-refunds
+ *
+ * Returns a list of all refunds with "failed" status.
+ * Useful for admin dashboard to see refunds that need attention.
+ */
+const GET = async (req, res) => {
+    const paymentService = req.scope.resolve(utils_2.Modules.PAYMENT);
+    try {
+        // Get query parameters for pagination/filtering
+        const limit = req.query.limit
+            ? parseInt(req.query.limit, 10)
+            : 50;
+        const offset = req.query.offset
+            ? parseInt(req.query.offset, 10)
+            : 0;
+        const currencyCodeFilter = req.query.currency_code;
+        const errorCodeFilter = req.query.error_code;
+        const returnIdFilter = req.query.return_id;
+        const orderIdFilter = req.query.order_id;
+        // List all payment collections
+        // Note: This is a simplified approach. In production, you might want
+        // to use a more efficient query method or create a custom service
+        // We fetch more than needed to allow filtering before pagination
+        const paymentCollections = await paymentService.listPaymentCollections?.({ limit: 1000, offset: 0 });
+        const failedRefunds = [];
+        if (paymentCollections && Array.isArray(paymentCollections)) {
+            for (const collection of paymentCollections) {
+                const collectionWithRefunds = collection;
+                // Check refunds in collection
+                const refunds = collectionWithRefunds.refunds || [];
+                for (const refund of refunds) {
+                    const refundData = refund;
+                    const metadata = refundData.metadata || {};
+                    // Check if refund has failed status
+                    if (metadata.refund_status === "failed") {
+                        const refundRecord = {
+                            refund_id: refundData.id,
+                            amount: refundData.amount,
+                            currency_code: refundData.currency_code,
+                            payment_error: metadata.payment_error,
+                            payment_error_code: metadata.payment_error_code,
+                            failed_at: metadata.failed_at,
+                            retry_count: metadata.retry_count || 0,
+                            last_retry_at: metadata.last_retry_at,
+                            return_id: metadata.return_id,
+                            order_id: metadata.order_id,
+                            created_at: refundData.created_at,
+                        };
+                        // Apply filters
+                        if (currencyCodeFilter &&
+                            refundRecord.currency_code !== currencyCodeFilter) {
+                            continue;
+                        }
+                        if (errorCodeFilter &&
+                            refundRecord.payment_error_code !== errorCodeFilter) {
+                            continue;
+                        }
+                        if (returnIdFilter &&
+                            refundRecord.return_id !== returnIdFilter) {
+                            continue;
+                        }
+                        if (orderIdFilter &&
+                            refundRecord.order_id !== orderIdFilter) {
+                            continue;
+                        }
+                        failedRefunds.push(refundRecord);
+                    }
+                    // Also check payment collection metadata for fallback refunds
+                    const collectionMetadata = collectionWithRefunds.metadata || {};
+                    const refundsInMetadata = collectionMetadata.refunds || [];
+                    for (const metaRefund of refundsInMetadata) {
+                        const metaRefundData = metaRefund;
+                        if (metaRefundData.refund_status === "failed" &&
+                            !failedRefunds.find((r) => r.refund_id ===
+                                metaRefundData.id)) {
+                            const refundRecord = {
+                                refund_id: metaRefundData.id,
+                                payment_error: metaRefundData.payment_error,
+                                payment_error_code: metaRefundData.payment_error_code,
+                                refund_status: "failed",
+                                return_id: metaRefundData.return_id,
+                                order_id: metaRefundData.order_id,
+                            };
+                            // Apply filters
+                            if (returnIdFilter &&
+                                refundRecord.return_id !== returnIdFilter) {
+                                continue;
+                            }
+                            if (orderIdFilter &&
+                                refundRecord.order_id !== orderIdFilter) {
+                                continue;
+                            }
+                            failedRefunds.push(refundRecord);
+                        }
+                    }
+                }
+            }
+        }
+        // Sort by failed_at (most recent first) or created_at
+        failedRefunds.sort((a, b) => {
+            const dateA = a.failed_at
+                ? new Date(a.failed_at).getTime()
+                : a.created_at
+                    ? new Date(a.created_at).getTime()
+                    : 0;
+            const dateB = b.failed_at
+                ? new Date(b.failed_at).getTime()
+                : b.created_at
+                    ? new Date(b.created_at).getTime()
+                    : 0;
+            return dateB - dateA; // Descending order
+        });
+        const totalCount = failedRefunds.length;
+        // Apply pagination
+        const paginatedRefunds = failedRefunds.slice(offset, offset + limit);
+        return res.json({
+            failed_refunds: paginatedRefunds,
+            count: totalCount,
+            limit,
+            offset,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Failed to retrieve failed refunds: ${errorMessage}`);
+    }
+};
+exports.GET = GET;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/api/store/returns/[id]/payment-details/route.js

@@ -1,8 +1,59 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.POST = void 0;
+exports.POST = exports.GET = void 0;
 const utils_1 = require("@medusajs/framework/utils");
 const utils_2 = require("@medusajs/framework/utils");
+const process_cod_refund_workflow_1 = __importDefault(require("../../../../../workflows/process-cod-refund-workflow"));
+/**
+ * GET endpoint to retrieve current payment details and refund status
+ *
+ * GET /store/returns/[id]/payment-details
+ */
+const GET = async (req, res) => {
+    const { id: return_id } = req.params;
+    if (!return_id) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Return ID is required");
+    }
+    // Get order service to retrieve return
+    const orderService = req.scope.resolve(utils_2.Modules.ORDER);
+    const paymentService = req.scope.resolve(utils_2.Modules.PAYMENT);
+    // Find return by ID
+    const returnRecord = await findReturnById(orderService, return_id);
+    if (!returnRecord) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Return with ID ${return_id} not found`);
+    }
+    // Get order to verify customer ownership
+    const orderId = returnRecord.order_id;
+    const order = await orderService.retrieveOrder(orderId);
+    // Verify customer ownership
+    const authContext = req.auth_context;
+    if (authContext?.actor_type === "customer") {
+        const customerId = authContext.actor_id;
+        if (order.customer_id !== customerId) {
+            throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNAUTHORIZED, "You are not authorized to view this return");
+        }
+    }
+    // Get current payment details from metadata
+    const metadata = returnRecord.metadata || {};
+    const paymentDetails = metadata.refund_payment_details;
+    const lastUpdatedAt = metadata.payment_details_updated_at;
+    const paymentDetailsHistory = metadata.payment_details_history || [];
+    // Get refund status
+    const refundStatus = await getRefundStatusForReturn(orderService, paymentService, return_id, orderId);
+    const refundStatusValue = refundStatus.status;
+    const canUpdate = refundStatusValue !== "succeeded";
+    return res.json({
+        payment_details: paymentDetails || null,
+        refund_status: refundStatusValue,
+        can_update: canUpdate,
+        last_updated_at: lastUpdatedAt || null,
+        payment_details_history_count: paymentDetailsHistory.length,
+    });
+};
+exports.GET = GET;
 const POST = async (req, res) => {
     const { id: return_id } = req.params;
     const paymentDetails = req.body;
@@ -21,6 +72,7 @@ const POST = async (req, res) => {
     }
     // Get order service to retrieve return
     const orderService = req.scope.resolve(utils_2.Modules.ORDER);
+    const paymentService = req.scope.resolve(utils_2.Modules.PAYMENT);
     // Find return by ID
     // Note: In Medusa, returns are linked to orders, so we need to search through orders
     // This is a simplified approach - in production, you might want to use a more efficient query
@@ -39,13 +91,48 @@ const POST = async (req, res) => {
             throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNAUTHORIZED, "You are not authorized to update this return");
         }
     }
-    // Update return metadata with payment details
+    // Check refund status before allowing update
+    const refundStatus = await getRefundStatusForReturn(orderService, paymentService, return_id, orderId);
+    // Reject update if refund is already succeeded
+    if (refundStatus.status === "succeeded") {
+        return res.status(400).json({
+            success: false,
+            error: "Payment details cannot be updated after refund is successful",
+            refund_status: "succeeded",
+            refund_id: refundStatus.refund_id,
+        });
+    }
+    // Get current metadata
     const currentMetadata = returnRecord.metadata || {};
+    // Get current payment details for history
+    const currentPaymentDetails = currentMetadata.refund_payment_details;
+    // Build payment details history
+    const paymentDetailsHistory = currentMetadata.payment_details_history || [];
+    // Add current payment details to history if they exist
+    if (currentPaymentDetails) {
+        const historyEntry = {
+            payment_details: currentPaymentDetails,
+            updated_at: currentMetadata.payment_details_updated_at ||
+                new Date().toISOString(),
+            reason: refundStatus.status === "failed" ? "refund_failed" : "user_update",
+        };
+        // Add to history (limit to last 10 entries)
+        paymentDetailsHistory.push(historyEntry);
+        if (paymentDetailsHistory.length > 10) {
+            paymentDetailsHistory.shift(); // Remove oldest entry
+        }
+    }
+    // Update return metadata with payment details
     const updatedMetadata = {
         ...currentMetadata,
         refund_payment_details: paymentDetails,
         payment_details_updated_at: new Date().toISOString(),
+        payment_details_history: paymentDetailsHistory,
+        // Cache refund status for quick access
+        refund_status: refundStatus.status,
     };
+    // Store previous refund status to check if we need to trigger retry
+    const previousRefundStatus = refundStatus.status;
     // Attempt to update return metadata via order service
     // Note: Medusa v2 may not expose direct return update API
     // We'll try to update through the order service if available
@@ -93,12 +180,27 @@ const POST = async (req, res) => {
         console.warn(`[payment-details] Payment details metadata structure is correct but may not be persisted. ` +
             `This is a known limitation when Medusa's return update API is not available.`);
     }
+    // If refund was failed and payment details are updated, trigger auto-retry
+    if (previousRefundStatus === "failed") {
+        // Trigger refund retry asynchronously (don't await)
+        triggerRefundRetry(req.scope, return_id, orderId).catch((error) => {
+            console.error(`[payment-details] Error triggering refund retry for return ${return_id}:`, error instanceof Error ? error.message : error);
+        });
+    }
     return res.json({
         success: true,
         message: "Payment details saved successfully",
         return_id,
-        note: "Payment details have been processed. If return update API is not available in your Medusa version, " +
-            "you may need to implement a custom return module to persist metadata.",
+        refund_status: refundStatus.status,
+        can_update: refundStatus.status !== "succeeded",
+        payment_details_history_count: paymentDetailsHistory.length,
+        ...(previousRefundStatus === "failed" && {
+            note: "Refund retry has been automatically initiated with updated payment details",
+        }),
+        ...(previousRefundStatus !== "failed" && {
+            note: "Payment details have been processed. If return update API is not available in your Medusa version, " +
+                "you may need to implement a custom return module to persist metadata.",
+        }),
     });
 };
 exports.POST = POST;
@@ -130,4 +232,95 @@ async function findReturnById(orderService, returnId) {
     }
     return null;
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Helper function to get refund status for a return
+ * Checks payment collection refunds to find refund linked to return_id
+ */
+async function getRefundStatusForReturn(orderService, paymentService, return_id, order_id) {
+    try {
+        // Retrieve order with payment collection
+        const order = await orderService.retrieveOrder(order_id, {
+            relations: ["payment_collection"],
+        });
+        if (!order) {
+            return { status: null };
+        }
+        // Get payment collection ID
+        const orderWithPayment = order;
+        const paymentCollectionId = orderWithPayment.payment_collection_id;
+        if (!paymentCollectionId) {
+            return { status: null };
+        }
+        // Retrieve payment collection with refunds
+        const paymentCollection = await paymentService.retrievePaymentCollection(paymentCollectionId, {
+            relations: ["refunds"],
+        });
+        if (!paymentCollection) {
+            return { status: null };
+        }
+        // Check refunds in collection
+        const paymentCollectionWithRefunds = paymentCollection;
+        const refunds = paymentCollectionWithRefunds.refunds || [];
+        // Find refund linked to this return
+        for (const refund of refunds) {
+            const refundData = refund;
+            const metadata = refundData.metadata || {};
+            // Check if refund is linked to this return
+            if (metadata.return_id === return_id) {
+                const refundStatus = metadata.refund_status;
+                return {
+                    status: refundStatus || null,
+                    refund_id: refundData.id,
+                };
+            }
+        }
+        // Also check payment collection metadata for fallback refunds
+        const collectionMetadata = paymentCollectionWithRefunds.metadata || {};
+        const refundTransactions = collectionMetadata.refund_transactions || {};
+        // Check each refund transaction
+        for (const [refundId, refundData] of Object.entries(refundTransactions)) {
+            const refundInfo = refundData;
+            if (refundInfo.return_id === return_id) {
+                return {
+                    status: refundInfo.refund_status || null,
+                    refund_id: refundId,
+                };
+            }
+        }
+        return { status: null };
+    }
+    catch (error) {
+        console.error(`[getRefundStatusForReturn] Error checking refund status for return ${return_id}:`, error instanceof Error ? error.message : error);
+        return { status: null };
+    }
+}
+/**
+ * Helper function to trigger refund retry when payment details are updated
+ * Executes workflow asynchronously without blocking the response
+ */
+async function triggerRefundRetry(scope, return_id, order_id) {
+    try {
+        // Execute workflow asynchronously (don't await to avoid blocking)
+        (0, process_cod_refund_workflow_1.default)(scope)
+            .run({
+            input: {
+                return_id,
+                order_id,
+            },
+        })
+            .then(({ result }) => {
+            console.log(`[triggerRefundRetry] Refund retry initiated successfully for return ${return_id}`, {
+                refund_id: result.refund_id,
+                amount: result.amount,
+                currency_code: result.currency_code,
+            });
+        })
+            .catch((error) => {
+            console.error(`[triggerRefundRetry] Refund retry failed for return ${return_id}:`, error instanceof Error ? error.message : error);
+        });
+    }
+    catch (error) {
+        console.error(`[triggerRefundRetry] Error initiating refund retry for return ${return_id}:`, error instanceof Error ? error.message : error);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route.js","sourceRoot":"","sources":["../../../../../../../../src/api/store/returns/[id]/payment-details/route.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/config/plugin-options.js

@@ -26,6 +26,7 @@ const OrderManagementPluginOptionsSchema = zod_1.z.object({
         providerSelection: zod_1.z.enum(["auto", "manual"]).default("auto"),
     })
         .optional(),
+    paymentProcessing: zod_1.z.enum(["automatic", "manual"]).default("automatic"),
 });
 function normalizeOrderManagementOptions(input) {
     const parsed = OrderManagementPluginOptionsSchema.parse(input ?? {});
@@ -37,6 +38,7 @@ function normalizeOrderManagementOptions(input) {
                 providerSelection: parsed.refundProviders.providerSelection,
             }
             : undefined,
+        paymentProcessing: parsed.paymentProcessing,
     };
 }
 exports.DEFAULT_ORDER_MANAGEMENT_OPTIONS = normalizeOrderManagementOptions({});
@@ -56,4 +58,4 @@ function resolveOrderManagementOptions(configModule) {
     }
     return exports.DEFAULT_ORDER_MANAGEMENT_OPTIONS;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/subscribers/return-received.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.config = void 0;
 exports.default = returnReceivedHandler;
+const utils_1 = require("@medusajs/framework/utils");
 const process_cod_refund_workflow_1 = __importDefault(require("../workflows/process-cod-refund-workflow"));
+const plugin_options_1 = require("../config/plugin-options");
 /**
  * Subscriber for return.updated events
  *
@@ -43,6 +45,16 @@ async function returnReceivedHandler({ event: { data }, container, }) {
         console.log(`[return-received] Return ${returnId} was already in "received" status. Skipping duplicate processing.`);
         return;
     }
+    // Check payment processing mode from plugin configuration
+    const configModule = container.resolve(utils_1.ContainerRegistrationKeys.CONFIG_MODULE);
+    const pluginOptions = (0, plugin_options_1.resolveOrderManagementOptions)(configModule);
+    const paymentProcessing = pluginOptions.paymentProcessing || "automatic";
+    if (paymentProcessing === "manual") {
+        console.log(`[return-received] Payment processing is set to "manual" mode. ` +
+            `Skipping automatic refund processing for return ${returnId}. ` +
+            `Admin will process refund manually.`);
+        return;
+    }
     try {
         console.log(`[return-received] Processing COD refund for return ${returnId}, order ${orderId}`);
         // Execute workflow to process COD refund
@@ -88,4 +100,4 @@ async function returnReceivedHandler({ event: { data }, container, }) {
 exports.config = {
     event: "return.updated",
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/process-cod-refund-workflow.js

@@ -36,6 +36,7 @@ exports.processCodRefundWorkflow = (0, workflows_sdk_1.createWorkflow)("process-
     // If payment details are not provided, skip payment processing
     // This allows the workflow to still create refund records for manual processing
     let transaction_id;
+    let paymentError;
     if (has_payment_details && payment_details) {
         // Step 5: Validate payment method is supported for currency
         const { selected_method, payment_details: validatedPaymentDetails } = (0, select_payment_method_step_1.selectPaymentMethodStep)({
@@ -58,16 +59,28 @@ exports.processCodRefundWorkflow = (0, workflows_sdk_1.createWorkflow)("process-
             return_id: input.return_id,
             order_id: input.order_id,
         });
-        transaction_id = gatewayTransactionId;
+        // Check if payment processing failed
+        if (!refund_result.success) {
+            paymentError = {
+                error_message: refund_result.error_message,
+                error_code: refund_result.error_code,
+            };
+            // Don't set transaction_id on failure
+        }
+        else {
+            transaction_id = gatewayTransactionId;
+        }
     }
-    // Step 8: Create refund record with transaction ID
+    // Step 8: Create refund record with transaction ID or error details
+    // Always create refund record, even on failure, so we can track failures
     const { refund_id, amount: refundAmount, currency_code: refundCurrencyCode } = (0, create_refund_record_step_1.createRefundRecordStep)({
         payment_collection_id: payment_collection.id,
         amount,
         currency_code: refundCurrency,
         order_id: input.order_id,
         return_id: input.return_id,
-        transaction_id, // Include gateway transaction ID
+        transaction_id, // Include gateway transaction ID (if successful)
+        payment_error: paymentError, // Include error details (if failed)
     });
     // Step 9: Update payment status
     (0, update_payment_status_step_1.updatePaymentStatusStep)({
@@ -83,4 +96,4 @@ exports.processCodRefundWorkflow = (0, workflows_sdk_1.createWorkflow)("process-
     });
 });
 exports.default = exports.processCodRefundWorkflow;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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