order-management 0.0.1

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

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+exports.default = returnReceivedHandler;
+const process_cod_refund_workflow_1 = __importDefault(require("../workflows/process-cod-refund-workflow"));
+/**
+ * Subscriber for return.updated events
+ *
+ * This subscriber listens to Medusa's built-in `return.updated` event
+ * and automatically processes COD refunds when return status changes to "received".
+ *
+ * Logic:
+ * - Listens to return.updated events
+ * - Checks if status changed to "received"
+ * - Verifies order is COD (via workflow)
+ * - Triggers COD refund workflow
+ * - Handles errors gracefully (doesn't break main flow)
+ */
+async function returnReceivedHandler({ event: { data }, container, }) {
+    const returnId = data.id;
+    const orderId = data.order_id;
+    const status = data.status;
+    const previousStatus = data.previous_status;
+    console.log(`[return-received] Event received for return: ${returnId}, order: ${orderId}, status: ${status}`);
+    if (!returnId) {
+        console.error("[return-received] No return ID in event data");
+        return;
+    }
+    if (!orderId) {
+        console.error("[return-received] No order ID in event data");
+        return;
+    }
+    // Only process if status is "received"
+    if (status !== "received") {
+        console.log(`[return-received] Return ${returnId} status is "${status}", not "received". Skipping COD refund processing.`);
+        return;
+    }
+    // Check if status actually changed to "received" (avoid processing if already received)
+    if (previousStatus === "received") {
+        console.log(`[return-received] Return ${returnId} was already in "received" status. Skipping duplicate processing.`);
+        return;
+    }
+    try {
+        console.log(`[return-received] Processing COD refund for return ${returnId}, order ${orderId}`);
+        // Execute workflow to process COD refund
+        const { result } = await (0, process_cod_refund_workflow_1.default)(container).run({
+            input: {
+                return_id: returnId,
+                order_id: orderId,
+            },
+        });
+        console.log(`[return-received] ✓ COD refund processed successfully for return ${returnId}:`, {
+            refund_id: result.refund_id,
+            amount: result.amount,
+            currency_code: result.currency_code,
+            order_id: result.order_id,
+        });
+    }
+    catch (error) {
+        // Log error but don't throw - subscriber errors shouldn't break the main flow
+        // The workflow will handle validation (e.g., if order is not COD, it will throw)
+        // We catch here to prevent breaking the return update flow
+        if (error instanceof Error) {
+            // Check if error is because order is not COD (expected case)
+            if (error.message.includes("COD") ||
+                error.message.includes("not COD") ||
+                error.message.includes("payment_type")) {
+                console.log(`[return-received] Order ${orderId} is not COD. Skipping refund processing:`, error.message);
+                return;
+            }
+            // Other errors should be logged
+            console.error(`[return-received] ✗ Error processing COD refund for return ${returnId}, order ${orderId}:`, error.message);
+        }
+        else {
+            console.error(`[return-received] ✗ Unknown error processing COD refund for return ${returnId}, order ${orderId}:`, error);
+        }
+    }
+}
+/**
+ * Subscriber configuration
+ *
+ * Listens to Medusa's built-in return.updated event
+ * This event is triggered when a return status is updated.
+ */
+exports.config = {
+    event: "return.updated",
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2luLW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHlwZXMvcGx1Z2luLW9wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/.medusa/server/src/types/refund-payment.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVmdW5kLXBheW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvdHlwZXMvcmVmdW5kLXBheW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/.medusa/server/src/workflows/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.processCodRefundWorkflow = void 0;
+var process_cod_refund_workflow_1 = require("./process-cod-refund-workflow");
+Object.defineProperty(exports, "processCodRefundWorkflow", { enumerable: true, get: function () { return process_cod_refund_workflow_1.processCodRefundWorkflow; } });
+var process_cod_refund_workflow_2 = require("./process-cod-refund-workflow");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(process_cod_refund_workflow_2).default; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvd29ya2Zsb3dzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLDZFQUF3RTtBQUEvRCx1SUFBQSx3QkFBd0IsT0FBQTtBQUNqQyw2RUFBdUQ7QUFBOUMsdUlBQUEsT0FBTyxPQUFBIn0=

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processCodRefundWorkflow = void 0;
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const verify_cod_order_step_1 = require("./steps/verify-cod-order-step");
+const retrieve_order_and_payment_step_1 = require("./steps/retrieve-order-and-payment-step");
+const calculate_refund_amount_step_1 = require("./steps/calculate-refund-amount-step");
+const retrieve_return_payment_details_step_1 = require("./steps/retrieve-return-payment-details-step");
+const select_payment_method_step_1 = require("./steps/select-payment-method-step");
+const validate_payment_details_step_1 = require("./steps/validate-payment-details-step");
+const process_refund_payment_step_1 = require("./steps/process-refund-payment-step");
+const create_refund_record_step_1 = require("./steps/create-refund-record-step");
+const update_payment_status_step_1 = require("./steps/update-payment-status-step");
+exports.processCodRefundWorkflow = (0, workflows_sdk_1.createWorkflow)("process-cod-refund", (input) => {
+    // Step 1: Verify order is COD
+    const { is_cod } = (0, verify_cod_order_step_1.verifyCodOrderStep)({
+        order_id: input.order_id,
+    });
+    // If not COD, the step will throw an error, so we don't need to check here
+    // The workflow will fail gracefully if order is not COD
+    // Step 2: Retrieve order and payment with currency
+    const { order, payment_collection, currency_code } = (0, retrieve_order_and_payment_step_1.retrieveOrderAndPaymentStep)({
+        order_id: input.order_id,
+    });
+    // Step 3: Calculate refund amount
+    const { amount, currency_code: refundCurrency } = (0, calculate_refund_amount_step_1.calculateRefundAmountStep)({
+        return_id: input.return_id,
+        order_id: input.order_id,
+        currency_code,
+    });
+    // Step 4: Retrieve payment details from return
+    const { payment_details, has_payment_details } = (0, retrieve_return_payment_details_step_1.retrieveReturnPaymentDetailsStep)({
+        return_id: input.return_id,
+        order_id: input.order_id,
+    });
+    // If payment details are not provided, skip payment processing
+    // This allows the workflow to still create refund records for manual processing
+    let transaction_id;
+    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)({
+            currency_code: refundCurrency,
+            payment_details,
+        });
+        // Step 6: Validate payment details format
+        const { payment_details: finalPaymentDetails } = (0, validate_payment_details_step_1.validatePaymentDetailsStep)({
+            payment_details: validatedPaymentDetails,
+            payment_method: selected_method,
+            currency_code: refundCurrency,
+        });
+        // Step 7: Process actual refund via payment gateway
+        // Provider selection happens here based on configured providers
+        const { refund_result, transaction_id: gatewayTransactionId } = (0, process_refund_payment_step_1.processRefundPaymentStep)({
+            amount,
+            currency_code: refundCurrency,
+            payment_details: finalPaymentDetails,
+            payment_method: selected_method,
+            return_id: input.return_id,
+            order_id: input.order_id,
+        });
+        transaction_id = gatewayTransactionId;
+    }
+    // Step 8: Create refund record with transaction ID
+    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
+    });
+    // Step 9: Update payment status
+    (0, update_payment_status_step_1.updatePaymentStatusStep)({
+        payment_collection_id: payment_collection.id,
+        refund_id,
+        refund_amount: refundAmount,
+    });
+    return new workflows_sdk_1.WorkflowResponse({
+        refund_id,
+        amount: refundAmount,
+        currency_code: refundCurrencyCode,
+        order_id: input.order_id,
+    });
+});
+exports.default = exports.processCodRefundWorkflow;
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/calculate-refund-amount-step.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRefundAmountStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_2 = require("@medusajs/framework/utils");
+exports.calculateRefundAmountStep = (0, workflows_sdk_1.createStep)("calculate-refund-amount", async (input, { container }) => {
+    const { return_id, order_id, currency_code } = input;
+    if (!return_id) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Return ID is required to calculate refund amount");
+    }
+    if (!currency_code) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Currency code is required to calculate refund amount");
+    }
+    const orderService = container.resolve(utils_2.Modules.ORDER);
+    // Retrieve return with items
+    // Note: In Medusa v2, returns are part of the order module
+    // We need to retrieve the return and calculate refund from return items
+    const order = await orderService.retrieveOrder(order_id, {
+        relations: ["returns", "returns.items", "items"],
+    });
+    if (!order) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Order with ID ${order_id} not found`);
+    }
+    // Find the return by ID
+    // Type assertion needed because returns relation is not in OrderDTO type definition
+    // even though we requested it via relations
+    const orderWithReturns = order;
+    const returns = orderWithReturns.returns || [];
+    const returnRecord = returns.find((ret) => ret.id === return_id);
+    if (!returnRecord) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Return with ID ${return_id} not found for order ${order_id}`);
+    }
+    // Get refund amount from return
+    // Returns have a refund_amount field that is calculated when return is created
+    const refundAmount = returnRecord.refund_amount ?? 0;
+    if (refundAmount <= 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Return ${return_id} has invalid refund amount: ${refundAmount}`);
+    }
+    // Verify currency matches
+    const returnCurrency = returnRecord.currency_code ||
+        currency_code;
+    if (returnCurrency !== currency_code) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Currency mismatch: return currency ${returnCurrency} does not match order currency ${currency_code}`);
+    }
+    return new workflows_sdk_1.StepResponse({
+        amount: refundAmount,
+        currency_code: currency_code,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/create-refund-record-step.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRefundRecordStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_2 = require("@medusajs/framework/utils");
+exports.createRefundRecordStep = (0, workflows_sdk_1.createStep)("create-refund-record", async (input, { container }) => {
+    const { payment_collection_id, amount, currency_code, order_id, return_id, transaction_id, } = input;
+    if (!payment_collection_id) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Payment collection ID is required to create refund record");
+    }
+    if (!amount || amount <= 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid refund amount: ${amount}. Amount must be greater than 0`);
+    }
+    if (!currency_code) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Currency code is required to create refund record");
+    }
+    const paymentService = container.resolve(utils_2.Modules.PAYMENT);
+    const orderService = container.resolve(utils_2.Modules.ORDER);
+    // Retrieve return record to get timing information for Medusa refund detection
+    const order = await orderService.retrieveOrder(order_id, {
+        relations: ["returns"],
+    });
+    if (!order) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Order with ID ${order_id} not found`);
+    }
+    // Find the return record
+    const orderWithReturns = order;
+    const returns = orderWithReturns.returns || [];
+    const returnRecord = returns.find((ret) => ret.id === return_id);
+    if (!returnRecord) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Return with ID ${return_id} not found for order ${order_id}`);
+    }
+    // Get return updated_at for timing comparison (when status changed to "received")
+    const returnUpdatedAt = returnRecord.updated_at;
+    // Check if refund already exists for this return (idempotency)
+    const paymentCollection = await paymentService.retrievePaymentCollection(payment_collection_id, {
+        relations: ["refunds"],
+    });
+    if (!paymentCollection) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Payment collection ${payment_collection_id} not found`);
+    }
+    // Check for existing refunds linked to this return (Medusa's or ours)
+    // Type assertion needed because refunds relation is not in PaymentCollectionDTO type definition
+    // even though we requested it via relations
+    const paymentCollectionWithRefunds = paymentCollection;
+    const refunds = paymentCollectionWithRefunds.refunds || [];
+    // Enhanced detection: Check for our refund OR Medusa's refund
+    const existingRefund = refunds.find((refund) => {
+        const refundData = refund;
+        // Check if it's our refund (has return_id in metadata)
+        const metadata = refundData.metadata;
+        if (metadata?.return_id === return_id) {
+            return true;
+        }
+        // Check if it's Medusa's refund (matches amount, currency, and timing)
+        const refundAmount = refundData.amount;
+        const refundCurrency = refundData.currency_code;
+        const refundCreatedAt = refundData.created_at;
+        // If amount and currency match, check timing
+        if (refundAmount === amount &&
+            refundCurrency === currency_code &&
+            refundCreatedAt &&
+            returnUpdatedAt) {
+            const timeDiff = Math.abs(new Date(refundCreatedAt).getTime() -
+                new Date(returnUpdatedAt).getTime());
+            // Created within 5 minutes of return status change to "received"
+            // This indicates Medusa automatically created the refund
+            if (timeDiff < 5 * 60 * 1000) {
+                return true;
+            }
+        }
+        return false;
+    });
+    if (existingRefund) {
+        // Refund already exists (either ours or Medusa's), use it
+        const refundData = existingRefund;
+        const refundId = refundData.id;
+        const refundAmount = refundData.amount ?? amount;
+        const refundCurrency = refundData.currency_code ?? currency_code;
+        // If we have a gateway transaction_id, update the refund metadata
+        if (transaction_id) {
+            const currentMetadata = refundData.metadata || {};
+            // Update refund metadata with gateway transaction info
+            const updatedMetadata = {
+                ...currentMetadata,
+                transaction_id,
+                processed_via_gateway: true,
+                gateway_transaction_added_at: new Date().toISOString(),
+                return_id, // Ensure return_id is in metadata
+                order_id,
+                payment_type: "cod",
+            };
+            // Try to update refund metadata via payment collection
+            // Note: We update payment collection metadata as fallback since
+            // direct refund update may not be available
+            const paymentCollectionMetadata = paymentCollection.metadata || {};
+            // Store gateway transaction info in payment collection metadata
+            await paymentService.updatePaymentCollection?.(payment_collection_id, {
+                metadata: {
+                    ...paymentCollectionMetadata,
+                    refund_transactions: {
+                        ...(paymentCollectionMetadata.refund_transactions || {}),
+                        [refundId]: {
+                            transaction_id,
+                            processed_via_gateway: true,
+                            updated_at: new Date().toISOString(),
+                        },
+                    },
+                },
+            });
+        }
+        return new workflows_sdk_1.StepResponse({
+            refund_id: refundId,
+            amount: refundAmount,
+            currency_code: refundCurrency,
+        });
+    }
+    // Get payments from collection to link refund
+    const payments = paymentCollection.payments || [];
+    const payment = payments.find((p) => p.captured_at !== null);
+    if (!payment) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `No captured payment found in payment collection ${payment_collection_id}`);
+    }
+    const paymentId = payment.id;
+    // Create refund record
+    // Note: Medusa v2 payment module may use different method names
+    // Try createRefunds (plural) or store refund info in payment collection metadata
+    let refundId;
+    let refundAmount = amount;
+    let refundCurrency = currency_code;
+    try {
+        // Try createRefunds (plural) method if available
+        const refunds = await paymentService.createRefunds?.([
+            {
+                payment_id: paymentId,
+                amount,
+                currency_code,
+                created_by: "system",
+                metadata: {
+                    return_id,
+                    order_id,
+                    payment_type: "cod",
+                    refund_type: "return",
+                    transaction_id,
+                    processed_via_gateway: transaction_id ? true : false,
+                    refund_status: transaction_id ? "succeeded" : "pending",
+                },
+            },
+        ]);
+        if (refunds && Array.isArray(refunds) && refunds.length > 0) {
+            const refund = refunds[0];
+            refundId = refund.id;
+            refundAmount = refund.amount ?? amount;
+            refundCurrency = refund.currency_code ?? currency_code;
+        }
+        else {
+            // Fallback: Generate a refund ID and store in metadata
+            refundId = `refund_${return_id}_${Date.now()}`;
+            // Store refund info in payment collection metadata as fallback
+            const currentMetadata = paymentCollection.metadata || {};
+            await paymentService.updatePaymentCollection?.(payment_collection_id, {
+                metadata: {
+                    ...currentMetadata,
+                    refunds: [
+                        ...(currentMetadata.refunds || []),
+                        {
+                            id: refundId,
+                            payment_id: paymentId,
+                            amount,
+                            currency_code,
+                            return_id,
+                            order_id,
+                            transaction_id,
+                            created_at: new Date().toISOString(),
+                        },
+                    ],
+                },
+            });
+        }
+    }
+    catch (error) {
+        // If refund creation fails, generate ID and log
+        refundId = `refund_${return_id}_${Date.now()}`;
+        console.warn(`Could not create refund via payment service, using fallback ID: ${refundId}`, error);
+    }
+    return new workflows_sdk_1.StepResponse({
+        refund_id: refundId,
+        amount: refundAmount,
+        currency_code: refundCurrency,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/process-refund-payment-step.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRefundPaymentStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_2 = require("@medusajs/framework/utils");
+const refund_payment_1 = require("../../providers/refund-payment");
+const plugin_options_1 = require("../../config/plugin-options");
+exports.processRefundPaymentStep = (0, workflows_sdk_1.createStep)("process-refund-payment", async (input, { container }) => {
+    const { amount, currency_code, payment_details, payment_method, return_id, order_id, } = input;
+    if (!amount || amount <= 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Invalid refund amount: ${amount}`);
+    }
+    // Get plugin options from config module
+    const configModule = container.resolve(utils_2.ContainerRegistrationKeys.CONFIG_MODULE);
+    const pluginOptions = (0, plugin_options_1.resolveOrderManagementOptions)(configModule);
+    // Build provider config from plugin options or environment variables (backward compatibility)
+    const providerConfig = {
+        razorpay: pluginOptions.refundProviders?.credentials?.razorpay ||
+            (process.env.RAZORPAY_KEY_ID && process.env.RAZORPAY_KEY_SECRET
+                ? {
+                    keyId: process.env.RAZORPAY_KEY_ID,
+                    keySecret: process.env.RAZORPAY_KEY_SECRET,
+                }
+                : undefined),
+        stripe: pluginOptions.refundProviders?.credentials?.stripe ||
+            (process.env.STRIPE_API_KEY
+                ? {
+                    apiKey: process.env.STRIPE_API_KEY,
+                }
+                : undefined),
+    };
+    // Filter providers based on enabled list (if specified)
+    const enabledProviders = pluginOptions.refundProviders?.enabled;
+    if (enabledProviders && enabledProviders.length > 0) {
+        // Only enable providers that are in the enabled list
+        if (!enabledProviders.includes("razorpay")) {
+            providerConfig.razorpay = undefined;
+        }
+        if (!enabledProviders.includes("stripe")) {
+            providerConfig.stripe = undefined;
+        }
+    }
+    // Create providers
+    const providers = (0, refund_payment_1.createRefundProviders)(providerConfig);
+    if (providers.length === 0) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, "No payment providers configured. Please configure at least one payment provider (Razorpay or Stripe) via plugin options or environment variables.");
+    }
+    // Filter by enabled providers if specified
+    const availableProviders = enabledProviders && enabledProviders.length > 0
+        ? providers.filter((p) => enabledProviders.includes(p.getName()))
+        : providers;
+    // Select appropriate provider that supports currency + payment method
+    let selectedProvider = (0, refund_payment_1.selectProvider)(availableProviders, currency_code, payment_method);
+    // Fallback logic if no provider found: prefer provider based on currency
+    if (!selectedProvider) {
+        if (currency_code.toUpperCase() === "INR") {
+            // For INR, prefer Razorpay if available
+            selectedProvider =
+                availableProviders.find((p) => p.getName() === "razorpay") || null;
+        }
+        else {
+            // For other currencies, prefer Stripe if available
+            selectedProvider =
+                availableProviders.find((p) => p.getName() === "stripe") || null;
+        }
+    }
+    if (!selectedProvider) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `No payment provider found that supports ${payment_method} for currency ${currency_code}. Available providers: ${availableProviders.map((p) => p.getName()).join(", ")}`);
+    }
+    // Process refund
+    const refundResult = await selectedProvider.processRefund({
+        amount,
+        currency_code,
+        payment_details,
+        return_id,
+        order_id,
+    });
+    if (!refundResult.success) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.UNEXPECTED_STATE, `Refund processing failed: ${refundResult.error_message || "Unknown error"}`, refundResult.error_code);
+    }
+    return new workflows_sdk_1.StepResponse({
+        refund_result: refundResult,
+        transaction_id: refundResult.transaction_id,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/.medusa/server/src/workflows/steps/retrieve-order-and-payment-step.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrieveOrderAndPaymentStep = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const workflows_sdk_1 = require("@medusajs/framework/workflows-sdk");
+const utils_2 = require("@medusajs/framework/utils");
+exports.retrieveOrderAndPaymentStep = (0, workflows_sdk_1.createStep)("retrieve-order-and-payment", async (input, { container }) => {
+    const { order_id } = input;
+    if (!order_id) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, "Order ID is required to retrieve order and payment");
+    }
+    const orderService = container.resolve(utils_2.Modules.ORDER);
+    const paymentService = container.resolve(utils_2.Modules.PAYMENT);
+    // Retrieve order with payment collection
+    const order = await orderService.retrieveOrder(order_id, {
+        relations: ["payment_collection"],
+    });
+    if (!order) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Order with ID ${order_id} not found`);
+    }
+    // Extract currency code from order
+    const currencyCode = order.currency_code;
+    if (!currencyCode) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order ${order_id} does not have a currency code`);
+    }
+    // Retrieve payment collection
+    const orderWithPayment = order;
+    const paymentCollectionId = orderWithPayment.payment_collection_id;
+    if (!paymentCollectionId) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.INVALID_DATA, `Order ${order_id} does not have a payment collection`);
+    }
+    const paymentCollection = await paymentService.retrievePaymentCollection(paymentCollectionId, {
+        relations: ["payments", "payment_providers"],
+    });
+    if (!paymentCollection) {
+        throw new utils_1.MedusaError(utils_1.MedusaError.Types.NOT_FOUND, `Payment collection ${paymentCollectionId} not found`);
+    }
+    return new workflows_sdk_1.StepResponse({
+        order,
+        payment_collection: paymentCollection,
+        currency_code: currencyCode,
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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