payment-kit 1.20.13 → 1.20.15

package/api/src/libs/vendor-util/adapters/launcher-adapter.ts

@@ -89,7 +89,7 @@ export class LauncherAdapter implements VendorAdapter {
           amount: params.amount,
           currency: params.currency,
           quantity: params.quantity,
-          paymentIntentId: params.paymentIntentId,
+          invoiceId: params.invoiceId,
           customParams: params.customParams,
         },
         installationInfo: {

package/api/src/libs/vendor-util/adapters/types.ts

@@ -14,7 +14,7 @@ export interface FulfillOrderParams {
   productCode: string;
   customerId: string;
   quantity: number;
-  paymentIntentId: string;
+  invoiceId: string;
   amount: string;
   currency: string;
 
@@ -38,7 +38,7 @@ export interface OrderDetails {
   amount: string;
   currency: string;
   quantity: number;
-  paymentIntentId: string;
+  invoiceId: string;
   customParams?: Record<string, any>;
 }
 
@@ -66,7 +66,6 @@ export interface ReturnRequestParams {
   orderId: string;
   vendorOrderId?: string;
   reason: string;
-  paymentIntentId: string;
   customParams?: Record<string, any>;
 }
 

package/api/src/libs/vendor-util/fulfillment.ts

@@ -43,7 +43,7 @@ export class VendorFulfillmentService {
       checkoutSessionId: string;
       amount_total: string;
       customer_id: string;
-      payment_intent_id: string | null;
+      invoiceId: string;
       currency_id: string;
       customer_did: string;
     },
@@ -75,7 +75,7 @@ export class VendorFulfillmentService {
         productCode: vendorConfig.vendor_id,
         customerId: orderInfo.customer_id || '',
         quantity: 1,
-        paymentIntentId: orderInfo.payment_intent_id || '',
+        invoiceId: orderInfo.invoiceId,
         amount: orderInfo.amount_total,
         currency: orderInfo.currency_id,
 
@@ -124,34 +124,18 @@ export class VendorFulfillmentService {
     }
   }
 
-  static async createVendorPayouts(
-    checkoutSessionId: string,
-    fulfillmentResults?: VendorFulfillmentResult[]
-  ): Promise<void> {
+  static async createVendorPayouts(checkoutSession: CheckoutSession, paymentIntent: PaymentIntent): Promise<void> {
     try {
-      const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
-      if (!checkoutSession) {
-        throw new Error(`CheckoutSession not found: ${checkoutSessionId}`);
-      }
-
-      let paymentMethodId = '';
-      if (checkoutSession.payment_intent_id) {
-        const paymentIntent = await PaymentIntent.findByPk(checkoutSession.payment_intent_id);
-        if (paymentIntent) {
-          paymentMethodId = paymentIntent.payment_method_id;
-        }
-      }
+      const paymentMethodId = paymentIntent.payment_method_id;
+      const paymentIntentId = paymentIntent.id;
 
       // If fulfillmentResults not provided, calculate commission info
-      let commissionData = fulfillmentResults;
-      if (!commissionData) {
-        commissionData = checkoutSession.vendor_info?.map((vendorInfo: any) => ({
-          vendorId: vendorInfo.vendor_id,
-          orderId: vendorInfo.order_id,
-          status: vendorInfo.status,
-          commissionAmount: vendorInfo.commissionAmount,
-        })) as VendorFulfillmentResult[];
-      }
+      const commissionData = checkoutSession.vendor_info?.map((vendorInfo: any) => ({
+        vendorId: vendorInfo.vendor_id,
+        orderId: vendorInfo.order_id,
+        status: vendorInfo.status,
+        commissionAmount: vendorInfo.commissionAmount,
+      })) as VendorFulfillmentResult[];
 
       const payoutPromises = commissionData
         .filter((result) => result.status !== 'failed' && new BN(result.commissionAmount).gt(new BN('0')))
@@ -170,7 +154,7 @@ export class VendorFulfillmentService {
             amount: result.commissionAmount,
             currency_id: checkoutSession.currency_id,
             customer_id: checkoutSession.customer_id || '',
-            payment_intent_id: checkoutSession.payment_intent_id || '',
+            payment_intent_id: paymentIntentId,
             payment_method_id: paymentMethodId,
             status: paymentMethod?.type === 'stripe' ? 'deferred' : 'pending',
             attempt_count: 0,
@@ -187,12 +171,14 @@ export class VendorFulfillmentService {
       await Promise.all(payoutPromises);
 
       logger.info('Vendor payouts created', {
-        checkoutSessionId,
+        checkoutSessionId: checkoutSession.id,
+        paymentIntentId: paymentIntent.id,
         payoutCount: commissionData.filter((r) => r.status !== 'failed').length,
       });
     } catch (error: any) {
       logger.error('Failed to create vendor payouts', {
-        checkoutSessionId,
+        checkoutSessionId: checkoutSession.id,
+        paymentIntentId: paymentIntent.id,
         error: error.message,
       });
       throw error;

package/api/src/queues/vendors/commission.ts

@@ -1,29 +1,26 @@
 import { events } from '../../libs/event';
 import logger from '../../libs/logger';
 import createQueue from '../../libs/queue';
+import { Invoice } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { PaymentIntent } from '../../store/models/payment-intent';
-import { Product } from '../../store/models/product';
 import { Price } from '../../store/models/price';
+import { Product } from '../../store/models/product';
 import { depositVaultQueue } from '../payment';
 import { startVendorFulfillment, triggerCommissionProcess, triggerCoordinatorCheck } from './fulfillment-coordinator';
 
 type VendorCommissionJob = {
-  paymentIntentId: string;
+  invoiceId: string;
   retryOnError?: boolean;
 };
 
-async function checkIfPaymentIntentHasVendors(
-  paymentIntent: PaymentIntent,
-  checkoutSession: CheckoutSession
-): Promise<boolean> {
+async function checkIfPaymentIntentHasVendors(checkoutSession: CheckoutSession): Promise<boolean> {
   try {
     // Extract price_ids from line_items, then find corresponding product_ids
     const priceIds = checkoutSession.line_items.map((item: any) => item.price_id).filter(Boolean);
 
     if (priceIds.length === 0) {
       logger.warn('No price IDs found in checkout session line items', {
-        paymentIntentId: paymentIntent.id,
         checkoutSessionId: checkoutSession.id,
       });
       return false;
@@ -39,7 +36,6 @@ async function checkIfPaymentIntentHasVendors(
 
     if (productIds.length === 0) {
       logger.warn('No product IDs found from prices', {
-        paymentIntentId: paymentIntent.id,
         checkoutSessionId: checkoutSession.id,
         priceIds,
       });
@@ -57,28 +53,28 @@ async function checkIfPaymentIntentHasVendors(
     return hasVendorConfig;
   } catch (error: any) {
     logger.error('Failed to check vendor configuration', {
-      paymentIntentId: paymentIntent.id,
       error,
     });
     return false;
   }
 }
 
-async function executeDirectDepositVault(paymentIntent: PaymentIntent): Promise<void> {
-  const exist = await depositVaultQueue.get(`deposit-vault-${paymentIntent.currency_id}`);
+async function executeDirectDepositVault(invoice: Invoice): Promise<void> {
+  const currencyId = invoice.currency_id;
+  const exist = await depositVaultQueue.get(`deposit-vault-${currencyId}`);
   if (!exist) {
     depositVaultQueue.push({
-      id: `deposit-vault-${paymentIntent.currency_id}`,
-      job: { currencyId: paymentIntent.currency_id },
+      id: `deposit-vault-${currencyId}`,
+      job: { currencyId },
     });
     logger.info('Deposit vault job queued', {
-      paymentIntentId: paymentIntent.id,
-      currencyId: paymentIntent.currency_id,
+      paymentIntentId: invoice.payment_intent_id,
+      currencyId,
     });
   } else {
     logger.info('Deposit vault job already exists', {
-      paymentIntentId: paymentIntent.id,
-      currencyId: paymentIntent.currency_id,
+      paymentIntentId: invoice.payment_intent_id,
+      currencyId,
     });
   }
 }
@@ -88,53 +84,53 @@ export const handleVendorCommission = async (job: VendorCommissionJob) => {
 
   let checkoutSession: CheckoutSession | null = null;
   try {
-    const paymentIntent = await PaymentIntent.findByPk(job.paymentIntentId);
-    if (!paymentIntent) {
-      logger.warn('PaymentIntent not found', { id: job.paymentIntentId });
+    const invoice = await Invoice.findByPk(job.invoiceId);
+    if (!invoice) {
+      logger.warn('invoice not found', { id: job.invoiceId });
       return;
     }
 
     // Find CheckoutSession through PaymentIntent
-    checkoutSession = await CheckoutSession.findByPaymentIntentId(paymentIntent.id);
+    checkoutSession = await CheckoutSession.findByInvoiceId(invoice.id);
     if (!checkoutSession) {
-      await executeDirectDepositVault(paymentIntent);
+      await executeDirectDepositVault(invoice);
       return;
     }
 
-    const hasVendorConfig = await checkIfPaymentIntentHasVendors(paymentIntent, checkoutSession);
+    const hasVendorConfig = await checkIfPaymentIntentHasVendors(checkoutSession);
     if (!hasVendorConfig) {
-      await executeDirectDepositVault(paymentIntent);
+      await executeDirectDepositVault(invoice);
       return;
     }
 
     logger.info('Vendor configuration found, starting fulfillment process', {
-      paymentIntentId: paymentIntent.id,
+      invoiceId: invoice.id,
     });
 
     if (checkoutSession.fulfillment_status === 'completed') {
       logger.info('CheckoutSession already completed, directly trigger commission process', {
         checkoutSessionId: checkoutSession.id,
       });
-      await triggerCommissionProcess(checkoutSession.id, paymentIntent.id);
+      await triggerCommissionProcess(checkoutSession.id, invoice.id);
       return;
     }
 
-    await startVendorFulfillment(checkoutSession.id, paymentIntent.id);
+    await startVendorFulfillment(checkoutSession.id, invoice.id);
   } catch (error: any) {
     logger.error('Vendor commission decision failed, fallback to direct deposit vault', {
-      paymentIntentId: job.paymentIntentId,
+      invoiceId: job.invoiceId,
       error,
     });
 
     if (!checkoutSession) {
       logger.error('CheckoutSession not found via any method[handleVendorCommission]', {
-        paymentIntentId: job.paymentIntentId,
+        invoiceId: job.invoiceId,
       });
       return;
     }
 
     try {
-      triggerCoordinatorCheck(checkoutSession.id, job.paymentIntentId, 'vendor_commission_decision_failed');
+      triggerCoordinatorCheck(checkoutSession.id, job.invoiceId, 'vendor_commission_decision_failed');
     } catch (err: any) {
       logger.error('Failed to trigger coordinator check[handleVendorCommission]', { error: err });
     }
@@ -160,23 +156,17 @@ export const startVendorCommissionQueue = async () => {
   });
 
   payments.forEach(async (x) => {
-    const exist = await vendorCommissionQueue.get(`vendor-commission-${x.id}`);
-    if (!exist) {
-      vendorCommissionQueue.push({ id: x.id, job: { paymentIntentId: x.id, retryOnError: true } });
+    const id = `vendor-commission-${x.invoice_id}`;
+    const exist = await vendorCommissionQueue.get(id);
+    if (!exist && x.invoice_id) {
+      vendorCommissionQueue.push({ id, job: { invoiceId: x.invoice_id, retryOnError: true } });
     }
   });
 };
 
 events.on('invoice.paid', async (invoice) => {
   try {
-    const paymentIntent = await PaymentIntent.findOne({ where: { invoice_id: invoice.id } });
-
-    if (!paymentIntent) {
-      logger.warn('PaymentIntent not found', { id: invoice.id });
-      return;
-    }
-
-    const id = `vendor-commission-${paymentIntent.id}`;
+    const id = `vendor-commission-${invoice.id}`;
     const exist = await vendorCommissionQueue.get(id);
     if (exist) {
       logger.info('Vendor commission job already exists, skipping', { id });
@@ -185,7 +175,7 @@ events.on('invoice.paid', async (invoice) => {
 
     vendorCommissionQueue.push({
       id,
-      job: { paymentIntentId: paymentIntent.id, retryOnError: true },
+      job: { invoiceId: invoice.id, retryOnError: true },
     });
   } catch (error) {
     logger.error('Failed to trigger vendor commission queue', { invoiceId: invoice.id, error });

package/api/src/queues/vendors/fulfillment-coordinator.ts

@@ -12,12 +12,13 @@ import { Product } from '../../store/models/product';
 import { Refund } from '../../store/models/refund';
 import { sequelize } from '../../store/sequelize';
 import { depositVaultQueue } from '../payment';
+import { Invoice } from '../../store/models';
 
 export type VendorInfo = NonNullable<CheckoutSession['vendor_info']>[number];
 
 interface CoordinatorJob {
   checkoutSessionId: string;
-  paymentIntentId: string;
+  invoiceId: string;
   triggeredBy: string;
 }
 
@@ -28,11 +29,11 @@ export const fulfillmentCoordinatorQueue = createQueue({
   onJob: handleFulfillmentCoordination,
 });
 
-export async function startVendorFulfillment(checkoutSessionId: string, paymentIntentId: string): Promise<void> {
+export async function startVendorFulfillment(checkoutSessionId: string, invoiceId: string): Promise<void> {
   try {
     logger.info('Starting vendor fulfillment process', {
       checkoutSessionId,
-      paymentIntentId,
+      invoiceId,
     });
 
     const vendorConfigs = await getVendorConfigurations(checkoutSessionId);
@@ -43,7 +44,7 @@ export async function startVendorFulfillment(checkoutSessionId: string, paymentI
         checkoutSessionId,
       });
 
-      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+      await triggerCommissionProcess(checkoutSessionId, invoiceId);
       return;
     }
 
@@ -65,7 +66,7 @@ export async function startVendorFulfillment(checkoutSessionId: string, paymentI
 
       events.emit('vendor.fulfillment.queued', vendorFulfillmentJobId, {
         checkoutSessionId,
-        paymentIntentId,
+        invoiceId,
         vendorId: vendorConfig.vendor_id,
         vendorConfig,
         retryOnError: true,
@@ -79,7 +80,7 @@ export async function startVendorFulfillment(checkoutSessionId: string, paymentI
   } catch (error: any) {
     logger.error('Failed to start vendor fulfillment', {
       checkoutSessionId,
-      paymentIntentId,
+      invoiceId,
       error: error.message,
     });
     throw error;
@@ -88,7 +89,7 @@ export async function startVendorFulfillment(checkoutSessionId: string, paymentI
 
 export async function updateVendorFulfillmentStatus(
   checkoutSessionId: string,
-  paymentIntentId: string,
+  invoiceId: string,
   vendorId: string,
   result: 'completed' | 'failed' | 'max_retries_exceeded' | 'return_requested' | 'sent',
   details?: {
@@ -110,11 +111,11 @@ export async function updateVendorFulfillmentStatus(
     lastAttemptAt: new Date().toISOString(),
   });
 
-  await triggerCoordinatorCheck(checkoutSessionId, paymentIntentId, `vendor_${vendorId}_${result}`);
+  await triggerCoordinatorCheck(checkoutSessionId, invoiceId, `vendor_${vendorId}_${result}`);
 }
 
 export async function handleFulfillmentCoordination(job: CoordinatorJob) {
-  const { checkoutSessionId, paymentIntentId, triggeredBy } = job;
+  const { checkoutSessionId, invoiceId, triggeredBy } = job;
 
   logger.info('Processing fulfillment coordination', {
     checkoutSessionId,
@@ -129,7 +130,7 @@ export async function handleFulfillmentCoordination(job: CoordinatorJob) {
       logger.info('No vendors to coordinate, triggering commission directly', {
         checkoutSessionId,
       });
-      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+      await triggerCommissionProcess(checkoutSessionId, invoiceId);
       return;
     }
 
@@ -146,7 +147,7 @@ export async function handleFulfillmentCoordination(job: CoordinatorJob) {
         successfulVendors: analysis.successfulVendors.length,
       });
 
-      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+      await triggerCommissionProcess(checkoutSessionId, invoiceId);
     } else if (analysis.anyMaxRetriesExceeded || analysis.shouldTimeout || analysis.failedVendors.length > 0) {
       logger.warn('Some vendors failed, initiating full refund', {
         checkoutSessionId,
@@ -155,7 +156,7 @@ export async function handleFulfillmentCoordination(job: CoordinatorJob) {
         timeoutVendors: analysis.shouldTimeout ? 'detected' : 'none',
       });
 
-      await initiateFullRefund(paymentIntentId, 'vendor_failure_detected');
+      await initiateFullRefund(invoiceId, 'vendor_failure_detected');
     } else {
       logger.info('Some vendors still in progress, waiting for completion', {
         checkoutSessionId,
@@ -170,7 +171,7 @@ export async function handleFulfillmentCoordination(job: CoordinatorJob) {
       error: error.message,
     });
 
-    await initiateFullRefund(paymentIntentId, 'coordination_failed');
+    await initiateFullRefund(invoiceId, 'coordination_failed');
   }
 }
 
@@ -355,74 +356,94 @@ function analyzeVendorStates(vendorInfo: VendorInfo[], vendorConfigs: any[]) {
   };
 }
 
-export function triggerCoordinatorCheck(checkoutSessionId: string, paymentIntentId: string, triggeredBy: string) {
+export function triggerCoordinatorCheck(checkoutSessionId: string, invoiceId: string, triggeredBy: string) {
   const jobId = `coordinator-${checkoutSessionId}-${Date.now()}`;
 
   return fulfillmentCoordinatorQueue.push({
     id: jobId,
     job: {
       checkoutSessionId,
-      paymentIntentId,
+      invoiceId,
       triggeredBy,
     },
   });
 }
 
-export async function triggerCommissionProcess(checkoutSessionId: string, paymentIntentId: string): Promise<void> {
-  logger.info('Triggering commission process', {
-    checkoutSessionId,
-    paymentIntentId,
+export async function triggerCommissionProcess(checkoutSessionId: string, invoiceId: string): Promise<void> {
+  logger.info('Triggering commission process', { checkoutSessionId });
+
+  const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+  if (!checkoutSession) {
+    logger.error('Checkout session not found[triggerCommissionProcess]', { checkoutSessionId });
+    return;
+  }
+  const invoice = await Invoice.findByPk(invoiceId);
+  if (!invoice) {
+    logger.error('Invoice not found[triggerCommissionProcess]', { invoiceId });
+    return;
+  }
+  const paymentIntent = await PaymentIntent.findOne({
+    where: {
+      [Op.or]: [{ id: invoice.payment_intent_id || checkoutSession.payment_intent_id }, { invoice_id: invoiceId }],
+    },
   });
 
-  await VendorFulfillmentService.createVendorPayouts(checkoutSessionId);
-  await CheckoutSession.update({ fulfillment_status: 'completed' }, { where: { id: checkoutSessionId } });
+  if (!paymentIntent) {
+    logger.error('Payment intent not found[triggerCommissionProcess]', { checkoutSessionId });
+    return;
+  }
+
+  await VendorFulfillmentService.createVendorPayouts(checkoutSession, paymentIntent);
+  await checkoutSession.update({ fulfillment_status: 'completed' });
 
-  const paymentIntent = await PaymentIntent.findByPk(paymentIntentId);
   if (paymentIntent) {
     const jobId = `deposit-vault-${paymentIntent.currency_id}`;
     const existingJob = await depositVaultQueue.get(jobId);
 
     if (!existingJob) {
-      await depositVaultQueue.push({
+      depositVaultQueue.push({
         id: jobId,
         job: { currencyId: paymentIntent.currency_id },
       });
     }
+  } else {
+    logger.error('Payment intent not found for invoice', { invoiceId });
   }
 
   logger.info('Commission process triggered successfully', {
     checkoutSessionId,
-    paymentIntentId,
   });
 }
 
-export async function initiateFullRefund(paymentIntentId: string, reason: string): Promise<void> {
+export async function initiateFullRefund(invoiceId: string, reason: string): Promise<void> {
   logger.warn('Initiating full refund with compensation', {
-    paymentIntentId,
+    invoiceId,
     reason,
   });
 
   try {
-    const paymentIntent = await PaymentIntent.findByPk(paymentIntentId);
-    const checkoutSession = await CheckoutSession.findByPaymentIntentId(paymentIntentId);
+    const paymentIntent = await PaymentIntent.findOne({ where: { invoice_id: invoiceId } });
+    const checkoutSession = await CheckoutSession.findByInvoiceId(invoiceId);
 
     if (!checkoutSession || !paymentIntent) {
       logger.error('Missing data for full refund', {
-        paymentIntentId,
+        invoiceId,
+        paymentIntentId: paymentIntent?.id,
+        checkoutSessionId: checkoutSession?.id,
         hasCheckoutSession: !!checkoutSession,
         hasPaymentIntent: !!paymentIntent,
       });
       return;
     }
 
-    await CheckoutSession.update({ fulfillment_status: 'cancelled' }, { where: { id: checkoutSession.id } });
-    await requestReturnsFromCompletedVendors(checkoutSession.id, paymentIntentId, reason);
+    await checkoutSession.update({ fulfillment_status: 'cancelled' });
+    await requestReturnsFromCompletedVendors(checkoutSession, reason);
 
     // Calculate remaining amount using the same logic as subscription createProration
     const refunds = await Refund.findAll({
       where: {
         status: { [Op.not]: 'canceled' },
-        payment_intent_id: paymentIntentId,
+        payment_intent_id: paymentIntent.id,
         type: 'refund',
       },
     });
@@ -437,7 +458,7 @@ export async function initiateFullRefund(paymentIntentId: string, reason: string
     // If no remaining amount or already fully refunded, skip
     if (new BN(remaining).lte(new BN('0'))) {
       logger.info('Payment already fully refunded, skipping', {
-        paymentIntentId,
+        invoiceId,
         paymentAmount: paymentIntent.amount,
         totalRefundAmount: refundAmount.toString(),
         remaining,
@@ -478,52 +499,41 @@ export async function initiateFullRefund(paymentIntentId: string, reason: string
     logger.info('Full refund created, triggering refund processing', {
       refundId: refund.id,
       checkoutSessionId: checkoutSession.id,
-      paymentIntentId,
+      invoiceId,
       amount: refund.amount,
       reason,
     });
   } catch (error: any) {
     logger.error('Failed to create full refund', {
-      paymentIntentId,
+      invoiceId,
       reason,
       error: error.message,
     });
   }
 }
 
-async function requestReturnsFromCompletedVendors(
-  checkoutSessionId: string,
-  paymentIntentId: string,
-  reason: string
-): Promise<void> {
+async function requestReturnsFromCompletedVendors(checkoutSession: CheckoutSession, reason: string): Promise<void> {
   logger.info('Starting return request process', {
-    checkoutSessionId,
-    paymentIntentId,
+    checkoutSessionId: checkoutSession.id,
     reason,
   });
 
   try {
-    const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
-    if (!checkoutSession) {
-      logger.error('CheckoutSession not found for return request', { checkoutSessionId });
-      return;
-    }
-
     const vendorInfos = (checkoutSession.vendor_info as VendorInfo[]) || [];
     const completedVendors = vendorInfos.filter((vendor) => vendor.status === 'completed');
 
     if (completedVendors.length === 0) {
-      logger.info('No completed vendors to request returns from', { checkoutSessionId });
+      logger.info('No completed vendors to request returns from', { checkoutSessionId: checkoutSession.id });
       return;
     }
 
     logger.info(`Found ${completedVendors.length} completed vendors requiring return requests`, {
-      checkoutSessionId,
+      checkoutSessionId: checkoutSession.id,
       completedVendorIds: completedVendors.map((v) => v.vendor_id),
     });
 
     const returnRequestPromises = completedVendors.map((vendor) => {
-      return requestReturnFromSingleVendor(checkoutSessionId, paymentIntentId, vendor, reason);
+      return requestReturnFromSingleVendor(checkoutSession, vendor, reason);
     });
 
     const returnResults = await Promise.allSettled(returnRequestPromises);
@@ -547,27 +557,26 @@ async function requestReturnsFromCompletedVendors(
     });
 
     logger.info('Return request process completed', {
-      checkoutSessionId,
+      checkoutSessionId: checkoutSession.id,
       totalVendors: completedVendors.length,
       successful: returnResults.filter((r) => r.status === 'fulfilled').length,
       failed: returnResults.filter((r) => r.status === 'rejected').length,
     });
   } catch (error: any) {
     logger.error('Return request process failed', {
-      checkoutSessionId,
-      paymentIntentId,
+      checkoutSessionId: checkoutSession.id,
       error: error.message,
     });
   }
 }
 
 async function requestReturnFromSingleVendor(
-  checkoutSessionId: string,
-  paymentIntentId: string,
+  checkoutSession: CheckoutSession,
   vendor: VendorInfo,
   reason: string
 ): Promise<void> {
   logger.info('Requesting return for vendor', {
+    checkoutSessionId: checkoutSession.id,
     vendorId: vendor.vendor_id,
     orderId: vendor.order_id,
     reason,
@@ -582,7 +591,6 @@ async function requestReturnFromSingleVendor(
     const returnResult = await vendorAdapter.requestReturn({
       orderId: vendor.order_id,
       reason: `Return request due to: ${reason}`,
-      paymentIntentId,
       customParams: {
         returnType: 'order_failure',
         originalAmount: vendor.amount,
@@ -596,7 +604,7 @@ async function requestReturnFromSingleVendor(
       status = 'rejected' as 'rejected';
     }
 
-    await updateSingleVendorInfo(checkoutSessionId, vendor.vendor_id, {
+    await updateSingleVendorInfo(checkoutSession.id, vendor.vendor_id, {
       status: 'return_requested',
       returnRequest: {
         reason,
@@ -615,10 +623,10 @@ async function requestReturnFromSingleVendor(
     logger.error('Return request failed', {
       vendorId: vendor.vendor_id,
       orderId: vendor.order_id,
-      error: error.message,
+      error,
     });
 
-    await updateSingleVendorInfo(checkoutSessionId, vendor.vendor_id, {
+    await updateSingleVendorInfo(checkoutSession.id, vendor.vendor_id, {
       status: 'return_requested',
       error_message: `Return request failed: ${error.message}`,
     });