payment-kit 1.20.5 → 1.20.6

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

@@ -0,0 +1,627 @@
+import { events } from '../../libs/event';
+import { getLock } from '../../libs/lock';
+import logger from '../../libs/logger';
+import createQueue from '../../libs/queue';
+import { VendorFulfillmentService } from '../../libs/vendor-fulfillment';
+import { CheckoutSession } from '../../store/models/checkout-session';
+import { PaymentIntent } from '../../store/models/payment-intent';
+import { Price } from '../../store/models/price';
+import { Product } from '../../store/models/product';
+import { Refund } from '../../store/models/refund';
+import { sequelize } from '../../store/sequelize';
+import { depositVaultQueue } from '../payment';
+
+type VendorInfo = {
+  vendor_id: string;
+  vendor_key: string;
+  order_id: string;
+  status:
+    | 'pending'
+    | 'processing'
+    | 'completed'
+    | 'failed'
+    | 'cancelled'
+    | 'max_retries_exceeded'
+    | 'return_requested'
+    | 'sent';
+  service_url?: string;
+  error_message?: string;
+  amount: string;
+
+  attempts?: number;
+  lastAttemptAt?: string;
+  completedAt?: string;
+  commissionAmount?: string;
+
+  returnRequest?: {
+    reason: string;
+    requestedAt: string;
+    status: 'pending' | 'accepted' | 'rejected';
+    returnDetails?: string;
+  };
+};
+
+interface CoordinatorJob {
+  checkoutSessionId: string;
+  paymentIntentId: string;
+  triggeredBy: string;
+}
+
+const MAX_FULFILLMENT_TIMEOUT = 300000;
+
+export const fulfillmentCoordinatorQueue = createQueue({
+  name: 'fulfillment-coordinator',
+  onJob: handleFulfillmentCoordination,
+});
+
+export async function startVendorFulfillment(checkoutSessionId: string, paymentIntentId: string): Promise<void> {
+  try {
+    logger.info('Starting vendor fulfillment process', {
+      checkoutSessionId,
+      paymentIntentId,
+    });
+
+    const vendorConfigs = await getVendorConfigurations(checkoutSessionId);
+
+    // No vendor configuration → directly to cold wallets
+    if (vendorConfigs.length === 0) {
+      logger.info('No vendor configurations found, triggering commission directly', {
+        checkoutSessionId,
+      });
+
+      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+      return;
+    }
+
+    const initialVendorInfo: VendorInfo[] = vendorConfigs.map((config) => ({
+      vendor_id: config.vendor_id,
+      vendor_key: config.vendor_key,
+      order_id: '',
+      status: 'pending' as 'pending',
+      amount: config.amount || '0',
+      attempts: 0,
+      lastAttemptAt: new Date().toISOString(),
+    }));
+
+    await updateVendorInfo(checkoutSessionId, initialVendorInfo);
+
+    // Trigger a separate vendor-fulfillment queue for each vendor
+    for (const vendorConfig of vendorConfigs) {
+      const vendorFulfillmentJobId = `vendor-fulfillment-${checkoutSessionId}-${vendorConfig.vendor_id}`;
+
+      events.emit('vendor.fulfillment.queued', vendorFulfillmentJobId, {
+        checkoutSessionId,
+        paymentIntentId,
+        vendorId: vendorConfig.vendor_id,
+        vendorConfig,
+        retryOnError: true,
+      });
+    }
+
+    logger.info('Vendor fulfillment process has been triggered', {
+      checkoutSessionId,
+      vendorCount: vendorConfigs.length,
+    });
+  } catch (error: any) {
+    logger.error('Failed to start vendor fulfillment', {
+      checkoutSessionId,
+      paymentIntentId,
+      error: error.message,
+    });
+    throw error;
+  }
+}
+
+export async function updateVendorFulfillmentStatus(
+  checkoutSessionId: string,
+  paymentIntentId: string,
+  vendorId: string,
+  result: 'completed' | 'failed' | 'max_retries_exceeded' | 'return_requested' | 'sent',
+  details?: {
+    orderId?: string;
+    attempts?: number;
+    lastError?: string;
+    commissionAmount?: string;
+    serviceUrl?: string;
+  }
+): Promise<void> {
+  await updateSingleVendorInfo(checkoutSessionId, vendorId, {
+    status: result,
+    order_id: details?.orderId || '',
+    attempts: details?.attempts || 0,
+    error_message: details?.lastError,
+    commissionAmount: details?.commissionAmount,
+    service_url: details?.serviceUrl,
+    completedAt: result === 'completed' ? new Date().toISOString() : undefined,
+    lastAttemptAt: new Date().toISOString(),
+  });
+
+  await triggerCoordinatorCheck(checkoutSessionId, paymentIntentId, `vendor_${vendorId}_${result}`);
+}
+
+export async function handleFulfillmentCoordination(job: CoordinatorJob) {
+  const { checkoutSessionId, paymentIntentId, triggeredBy } = job;
+
+  logger.info('Processing fulfillment coordination', {
+    checkoutSessionId,
+    triggeredBy,
+  });
+
+  try {
+    const vendorInfo = await getVendorInfo(checkoutSessionId);
+    const vendorConfigs = await getVendorConfigurations(checkoutSessionId);
+
+    if (vendorConfigs.length === 0) {
+      logger.info('No vendors to coordinate, triggering commission directly', {
+        checkoutSessionId,
+      });
+      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+      return;
+    }
+
+    const analysis = analyzeVendorStates(vendorInfo, vendorConfigs);
+
+    logger.info('Vendor fulfillment analysis', {
+      checkoutSessionId,
+      analysis,
+    });
+
+    if (analysis.allCompleted) {
+      logger.info('All vendors completed successfully, triggering commission', {
+        checkoutSessionId,
+        successfulVendors: analysis.successfulVendors.length,
+      });
+
+      await triggerCommissionProcess(checkoutSessionId, paymentIntentId);
+    } else if (analysis.anyMaxRetriesExceeded || analysis.shouldTimeout || analysis.failedVendors.length > 0) {
+      logger.warn('Some vendors failed, initiating full refund', {
+        checkoutSessionId,
+        failedVendors: analysis.failedVendors.length,
+        maxRetriesExceededVendors: analysis.maxRetriesExceededVendors.length,
+        timeoutVendors: analysis.shouldTimeout ? 'detected' : 'none',
+      });
+
+      await initiateFullRefund(paymentIntentId, 'vendor_failure_detected');
+    } else {
+      logger.info('Some vendors still in progress, waiting for completion', {
+        checkoutSessionId,
+        pendingVendors: analysis.pendingVendors.length,
+        processingVendors: analysis.processingVendors.length,
+        failedVendors: analysis.failedVendors.length,
+      });
+    }
+  } catch (error: any) {
+    logger.error('Fulfillment coordination failed', {
+      checkoutSessionId,
+      error: error.message,
+    });
+
+    await initiateFullRefund(paymentIntentId, 'coordination_failed');
+  }
+}
+
+async function getVendorConfigurations(checkoutSessionId: string): Promise<any[]> {
+  const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+  if (!checkoutSession?.line_items) {
+    return [];
+  }
+
+  const priceIds = checkoutSession.line_items.map((item: any) => item.price_id).filter(Boolean);
+  if (priceIds.length === 0) {
+    return [];
+  }
+
+  const prices = await Price.findAll({
+    where: { id: priceIds },
+    attributes: ['id', 'product_id'],
+  });
+
+  const productIds = prices.map((price: any) => price.product_id).filter(Boolean);
+  if (productIds.length === 0) {
+    return [];
+  }
+
+  const product = await Product.findByPk(productIds[0]);
+  return product?.vendor_config || [];
+}
+
+async function getVendorInfo(checkoutSessionId: string): Promise<VendorInfo[]> {
+  const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+  return (checkoutSession?.vendor_info as VendorInfo[]) || [];
+}
+
+async function updateVendorInfo(checkoutSessionId: string, vendorInfo: VendorInfo[]): Promise<void> {
+  await CheckoutSession.update({ vendor_info: vendorInfo }, { where: { id: checkoutSessionId } });
+}
+
+async function updateSingleVendorInfo(
+  checkoutSessionId: string,
+  vendorId: string,
+  update: Partial<VendorInfo>
+): Promise<void> {
+  const lockKey = `vendor-info-${checkoutSessionId}`;
+
+  logger.info('updateVendorInfo - Before update', {
+    checkoutSessionId,
+    vendorId,
+    update,
+    lockKey,
+  });
+
+  const lock = await getLock(lockKey);
+
+  try {
+    await sequelize.transaction(async (transaction: any) => {
+      const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId, {
+        transaction,
+        lock: transaction.LOCK.UPDATE,
+      });
+
+      if (!checkoutSession) {
+        throw new Error(`CheckoutSession not found: ${checkoutSessionId}`);
+      }
+
+      const current = (checkoutSession.vendor_info as VendorInfo[]) || [];
+      const index = current.findIndex((vendor) => vendor.vendor_id === vendorId);
+
+      if (index >= 0) {
+        current[index] = {
+          ...current[index],
+          ...update,
+          vendor_id: current[index]?.vendor_id || vendorId,
+          order_id: update.order_id || current[index]?.order_id || '',
+          status: update.status || current[index]?.status || 'pending',
+          amount: update.amount || current[index]?.amount || '0',
+        } as VendorInfo;
+      } else {
+        current.push({
+          vendor_id: vendorId,
+          order_id: update.order_id || '',
+          status: update.status || 'pending',
+          amount: update.amount || '0',
+          ...update,
+        } as VendorInfo);
+      }
+
+      logger.info('updateVendorInfo - After merge, before database update (in transaction)', {
+        checkoutSessionId,
+        vendorId,
+        finalVendorInfo: current,
+        updatedVendorStatus: index >= 0 ? current[index]?.status : current[current.length - 1]?.status,
+      });
+
+      const fulfillmentStatus =
+        !checkoutSession.fulfillment_status ||
+        !['completed', 'failed', 'cancelled', 'max_retries_exceeded', 'return_requested'].includes(
+          checkoutSession.fulfillment_status
+        )
+          ? update.status
+          : undefined;
+
+      await CheckoutSession.update(
+        {
+          vendor_info: current,
+          fulfillment_status: fulfillmentStatus,
+        },
+        {
+          where: { id: checkoutSessionId },
+          transaction,
+        }
+      );
+
+      logger.info('updateVendorInfo - Database update completed (in transaction)', {
+        checkoutSessionId,
+        vendorId,
+        updateStatus: update.status,
+      });
+    });
+  } catch (error: any) {
+    logger.error('updateVendorInfo - Update failed', {
+      checkoutSessionId,
+      vendorId,
+      error: error.message,
+    });
+    throw error;
+  } finally {
+    lock.release();
+    logger.info('updateVendorInfo - Lock released', {
+      checkoutSessionId,
+      vendorId,
+      lockKey,
+    });
+  }
+}
+
+function analyzeVendorStates(vendorInfo: VendorInfo[], vendorConfigs: any[]) {
+  const vendorIds = vendorConfigs.map((config) => config.vendor_id);
+
+  const successfulVendors = vendorInfo.filter((vendor) => vendor.status === 'completed');
+  const failedVendors = vendorInfo.filter((vendor) => vendor.status === 'failed');
+  const maxRetriesExceededVendors = vendorInfo.filter((vendor) => vendor.status === 'max_retries_exceeded');
+  const pendingVendors = vendorInfo.filter((vendor) => vendor.status === 'pending');
+  const processingVendors = vendorInfo.filter((vendor) => vendor.status === 'processing' || vendor.status === 'sent');
+  const sentVendors = vendorInfo.filter((vendor) => vendor.status === 'sent');
+
+  const allCompleted = successfulVendors.length === vendorIds.length;
+  const anyMaxRetriesExceeded = maxRetriesExceededVendors.length > 0;
+  const allPending = pendingVendors.length === vendorIds.length;
+  const someProcessing = processingVendors.length > 0;
+
+  const now = Date.now();
+  const shouldTimeout = vendorInfo.some((vendor) => {
+    if (!vendor.lastAttemptAt) return false;
+    const timeSinceLastAttempt = now - new Date(vendor.lastAttemptAt).getTime();
+
+    if (vendor.status === 'pending' && timeSinceLastAttempt > MAX_FULFILLMENT_TIMEOUT) {
+      logger.warn('Vendor has been pending for too long, considering as timeout', {
+        vendorId: vendor.vendor_id,
+        status: vendor.status,
+        timeSinceLastAttempt: `${Math.floor(timeSinceLastAttempt / 1000)}s`,
+        timeoutThreshold: `${Math.floor(MAX_FULFILLMENT_TIMEOUT / 1000)}s`,
+      });
+      return true;
+    }
+
+    return timeSinceLastAttempt > MAX_FULFILLMENT_TIMEOUT;
+  });
+
+  return {
+    allCompleted,
+    sentVendors,
+    anyMaxRetriesExceeded,
+    allPending,
+    someProcessing,
+    shouldTimeout,
+    successfulVendors,
+    failedVendors,
+    maxRetriesExceededVendors,
+    pendingVendors,
+    processingVendors,
+    totalVendors: vendorIds.length,
+  };
+}
+
+export function triggerCoordinatorCheck(checkoutSessionId: string, paymentIntentId: string, triggeredBy: string) {
+  const jobId = `coordinator-${checkoutSessionId}-${Date.now()}`;
+
+  return fulfillmentCoordinatorQueue.push({
+    id: jobId,
+    job: {
+      checkoutSessionId,
+      paymentIntentId,
+      triggeredBy,
+    },
+  });
+}
+
+async function triggerCommissionProcess(checkoutSessionId: string, paymentIntentId: string): Promise<void> {
+  logger.info('Triggering commission process', {
+    checkoutSessionId,
+    paymentIntentId,
+  });
+
+  await VendorFulfillmentService.createVendorPayouts(checkoutSessionId);
+  await CheckoutSession.update({ fulfillment_status: 'completed' }, { where: { id: checkoutSessionId } });
+
+  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({
+        id: jobId,
+        job: { currencyId: paymentIntent.currency_id },
+      });
+    }
+  }
+
+  logger.info('Commission process triggered successfully', {
+    checkoutSessionId,
+    paymentIntentId,
+  });
+}
+
+export async function initiateFullRefund(paymentIntentId: string, reason: string): Promise<void> {
+  logger.warn('Initiating full refund with compensation', {
+    paymentIntentId,
+    reason,
+  });
+
+  try {
+    const paymentIntent = await PaymentIntent.findByPk(paymentIntentId);
+    const checkoutSession = await CheckoutSession.findByPaymentIntentId(paymentIntentId);
+
+    if (!checkoutSession || !paymentIntent) {
+      logger.error('Missing data for full refund', {
+        paymentIntentId,
+        hasCheckoutSession: !!checkoutSession,
+        hasPaymentIntent: !!paymentIntent,
+      });
+      return;
+    }
+
+    await CheckoutSession.update({ fulfillment_status: 'cancelled' }, { where: { id: checkoutSession.id } });
+    await requestReturnsFromCompletedVendors(checkoutSession.id, paymentIntentId, reason);
+
+    const refund = await Refund.create({
+      type: 'refund',
+      livemode: paymentIntent.livemode,
+      amount: paymentIntent.amount,
+      description: `Full refund due to ${reason}`,
+      status: 'pending',
+      reason,
+      currency_id: paymentIntent.currency_id,
+      customer_id: paymentIntent.customer_id || '',
+      payment_method_id: paymentIntent.payment_method_id,
+      payment_intent_id: paymentIntent.id,
+      invoice_id: paymentIntent.invoice_id,
+      subscription_id: checkoutSession.subscription_id || undefined,
+      attempt_count: 0,
+      attempted: false,
+      next_attempt: 0,
+      last_attempt_error: null,
+      starting_balance: '0',
+      ending_balance: '0',
+      starting_token_balance: {},
+      ending_token_balance: {},
+      metadata: {
+        checkout_session_id: checkoutSession.id,
+        refund_reason: reason,
+        auto_refund: true,
+        requested_by: 'coordinator',
+        ...(checkoutSession.subscription_id && { subscription_id: checkoutSession.subscription_id }),
+      },
+    });
+
+    logger.info('Full refund created, triggering refund processing', {
+      refundId: refund.id,
+      checkoutSessionId: checkoutSession.id,
+      paymentIntentId,
+      amount: refund.amount,
+      reason,
+    });
+
+    events.emit('refund.created', refund);
+  } catch (error: any) {
+    logger.error('Failed to create full refund', {
+      paymentIntentId,
+      reason,
+      error: error.message,
+    });
+  }
+}
+
+async function requestReturnsFromCompletedVendors(
+  checkoutSessionId: string,
+  paymentIntentId: string,
+  reason: string
+): Promise<void> {
+  logger.info('Starting return request process', {
+    checkoutSessionId,
+    paymentIntentId,
+    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 });
+      return;
+    }
+
+    logger.info(`Found ${completedVendors.length} completed vendors requiring return requests`, {
+      checkoutSessionId,
+      completedVendorIds: completedVendors.map((v) => v.vendor_id),
+    });
+
+    const returnRequestPromises = completedVendors.map((vendor) => {
+      return requestReturnFromSingleVendor(checkoutSessionId, paymentIntentId, vendor, reason);
+    });
+
+    const returnResults = await Promise.allSettled(returnRequestPromises);
+
+    returnResults.forEach((result, index) => {
+      const vendor = completedVendors[index];
+      if (vendor) {
+        if (result.status === 'fulfilled') {
+          logger.info('Return request submitted successfully', {
+            vendorId: vendor.vendor_id,
+            orderId: vendor.order_id,
+          });
+        } else {
+          logger.error('Return request failed', {
+            vendorId: vendor.vendor_id,
+            orderId: vendor.order_id,
+            error: result.reason,
+          });
+        }
+      }
+    });
+
+    logger.info('Return request process completed', {
+      checkoutSessionId,
+      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,
+      error: error.message,
+    });
+  }
+}
+
+async function requestReturnFromSingleVendor(
+  checkoutSessionId: string,
+  paymentIntentId: string,
+  vendor: VendorInfo,
+  reason: string
+): Promise<void> {
+  logger.info('Requesting return for vendor', {
+    vendorId: vendor.vendor_id,
+    orderId: vendor.order_id,
+    reason,
+  });
+
+  try {
+    const vendorAdapter = await VendorFulfillmentService.getVendorAdapter(vendor.vendor_id);
+    if (!vendorAdapter) {
+      throw new Error(`No adapter found for vendor: ${vendor.vendor_id}`);
+    }
+
+    const returnResult = await vendorAdapter.requestReturn({
+      orderId: vendor.order_id,
+      reason: `Return request due to: ${reason}`,
+      paymentIntentId,
+      customParams: {
+        returnType: 'order_failure',
+        originalAmount: vendor.amount,
+      },
+    });
+
+    let { status } = returnResult;
+    if (returnResult.status === 'requested') {
+      status = 'pending' as 'accepted';
+    } else if (returnResult.status === 'failed') {
+      status = 'rejected' as 'rejected';
+    }
+
+    await updateSingleVendorInfo(checkoutSessionId, vendor.vendor_id, {
+      status: 'return_requested',
+      returnRequest: {
+        reason,
+        requestedAt: new Date().toISOString(),
+        status: status as 'pending' | 'accepted' | 'rejected',
+        returnDetails: returnResult.message,
+      },
+    });
+
+    logger.info('Return request submitted successfully', {
+      vendorId: vendor.vendor_id,
+      orderId: vendor.order_id,
+      returnStatus: returnResult.status,
+    });
+  } catch (error: any) {
+    logger.error('Return request failed', {
+      vendorId: vendor.vendor_id,
+      orderId: vendor.order_id,
+      error: error.message,
+    });
+
+    await updateSingleVendorInfo(checkoutSessionId, vendor.vendor_id, {
+      status: 'return_requested',
+      error_message: `Return request failed: ${error.message}`,
+    });
+  }
+}