payment-kit 1.20.5 → 1.20.6

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

@@ -0,0 +1,97 @@
+import { events } from '../../libs/event';
+import logger from '../../libs/logger';
+import createQueue from '../../libs/queue';
+import { VendorFulfillmentService } from '../../libs/vendor-fulfillment';
+import { CheckoutSession } from '../../store/models/checkout-session';
+import { updateVendorFulfillmentStatus } from './vendor-fulfillment-coordinator';
+
+type VendorFulfillmentJob = {
+  checkoutSessionId: string;
+  paymentIntentId: string;
+  vendorId: string;
+  vendorConfig: any;
+  retryOnError?: boolean;
+};
+
+export const handleVendorFulfillment = async (job: VendorFulfillmentJob) => {
+  logger.debug('Raw job received in handleVendorFulfillment', {
+    job,
+    jobKeys: Object.keys(job),
+  });
+
+  const { checkoutSessionId, paymentIntentId, vendorId, vendorConfig } = job;
+
+  try {
+    const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+    if (!checkoutSession) {
+      throw new Error(`CheckoutSession not found: ${checkoutSessionId}`);
+    }
+
+    const orderInfo = {
+      amount_total: checkoutSession.amount_total,
+      customer_id: checkoutSession.customer_id || '',
+      payment_intent_id: checkoutSession.payment_intent_id || '',
+      currency_id: checkoutSession.currency_id,
+      customer_did: checkoutSession.customer_did || '',
+    };
+    const fulfillmentResult = await VendorFulfillmentService.fulfillSingleVendorOrder(orderInfo, vendorConfig);
+
+    logger.info('Vendor fulfillment has been sent', {
+      vendorId,
+      orderId: fulfillmentResult.orderId,
+      status: fulfillmentResult.status,
+    });
+
+    await updateVendorFulfillmentStatus(checkoutSessionId, paymentIntentId, vendorId, 'sent', {
+      orderId: fulfillmentResult.orderId,
+      commissionAmount: fulfillmentResult.commissionAmount,
+      serviceUrl: fulfillmentResult.serviceUrl,
+    });
+  } catch (error: any) {
+    logger.error('Vendor fulfillment failed', {
+      vendorId,
+      checkoutSessionId,
+      error: error.message,
+    });
+
+    await updateVendorFulfillmentStatus(checkoutSessionId, paymentIntentId, vendorId, 'failed', {
+      lastError: error.message,
+    });
+
+    throw error;
+  }
+};
+
+export const vendorFulfillmentQueue = createQueue<VendorFulfillmentJob>({
+  name: 'vendor-fulfillment',
+  onJob: handleVendorFulfillment,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+export const startVendorFulfillmentQueue = () => {
+  logger.debug('startVendorFulfillmentQueue');
+  return Promise.resolve();
+};
+
+events.on('vendor.fulfillment.queued', async (id, job) => {
+  try {
+    const exist = await vendorFulfillmentQueue.get(id);
+    if (!exist) {
+      vendorFulfillmentQueue.push({
+        id,
+        job,
+      });
+    } else {
+      logger.info('Vendor fulfillment job already exists, skipping', { id });
+    }
+  } catch (error: any) {
+    logger.error('Failed to handle vendor fulfillment queue event', {
+      id,
+      error: error.message,
+    });
+  }
+});

package/api/src/queues/vendor/vendor-status-check.ts

@@ -0,0 +1,179 @@
+import { joinURL } from 'ufo';
+import createQueue from '../../libs/queue';
+import { getBlockletJson } from '../../libs/util';
+import { VendorAdapterFactory } from '../../libs/vendor-adapter-factory';
+import { CheckoutSession } from '../../store/models/checkout-session';
+import { ProductVendor } from '../../store/models';
+import { fulfillmentCoordinatorQueue } from './vendor-fulfillment-coordinator';
+import logger from '../../libs/logger';
+import { vendorTimeoutMinutes } from '../../libs/env';
+
+export const startVendorStatusCheckSchedule = async () => {
+  const checkoutSessions = await CheckoutSession.findAll({
+    where: { fulfillment_status: 'sent' },
+  });
+
+  if (!checkoutSessions.length) {
+    return;
+  }
+
+  for (const checkoutSession of checkoutSessions) {
+    const vendorInfo = checkoutSession.vendor_info;
+    if (!vendorInfo?.length) {
+      return;
+    }
+
+    for (const vendor of vendorInfo) {
+      if (vendor.status === 'sent') {
+        vendorStatusCheckQueue.push({
+          id: `vendor-status-check-${checkoutSession.id}-${vendor.vendor_id}`,
+          job: {
+            checkoutSessionId: checkoutSession.id,
+            vendorId: vendor.vendor_id,
+          },
+        });
+      }
+    }
+  }
+};
+
+export const handleVendorStatusCheck = async (job: VendorStatusCheckJob) => {
+  const { checkoutSessionId, vendorId } = job;
+  logger.info('handleVendorStatusCheck', { checkoutSessionId, vendorId });
+
+  const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId, {
+    attributes: ['vendor_info', 'payment_intent_id'],
+  });
+
+  const vendor = checkoutSession?.vendor_info?.find((v) => v.vendor_id === vendorId);
+  if (!vendor) {
+    logger.error('vendor not found[handleVendorStatusCheck]', { checkoutSessionId, vendorId });
+    return { status: 'fail' };
+  }
+
+  const TIMEOUT_THRESHOLD = vendorTimeoutMinutes * 60 * 1000;
+  const now = Date.now();
+
+  if (vendor.lastAttemptAt) {
+    const timeSinceLastAttempt = now - new Date(vendor.lastAttemptAt).getTime();
+
+    if (timeSinceLastAttempt > TIMEOUT_THRESHOLD) {
+      logger.warn('Vendor timeout detected during status check', {
+        checkoutSessionId,
+        vendorId,
+        status: vendor.status,
+        timeSinceLastAttempt: `${Math.floor(timeSinceLastAttempt / 1000)}s`,
+        timeoutThreshold: `${vendorTimeoutMinutes}min (${Math.floor(TIMEOUT_THRESHOLD / 1000)}s)`,
+      });
+
+      vendor.status = 'failed';
+      vendor.error_message = `Timeout: ${vendor.status} status exceeded ${vendorTimeoutMinutes} minutes`;
+      vendor.lastAttemptAt = new Date().toISOString();
+
+      const updatedVendorInfo = checkoutSession?.vendor_info?.map((v) => {
+        if (v.vendor_id === vendorId) {
+          return { ...v, ...vendor };
+        }
+        return v;
+      });
+
+      await CheckoutSession.update({ vendor_info: updatedVendorInfo }, { where: { id: checkoutSessionId } });
+
+      fulfillmentCoordinatorQueue.push({
+        id: `fulfillment-coordinator-${checkoutSessionId}-${vendorId}`,
+        job: {
+          checkoutSessionId,
+          paymentIntentId: checkoutSession?.payment_intent_id || '',
+          triggeredBy: 'vendor-status-check-timeout',
+        },
+      });
+
+      return { status: 'failed', reason: 'timeout' };
+    }
+  }
+
+  try {
+    if (!vendor.app_url) {
+      const productVendor = await ProductVendor.findByPk(vendorId);
+      const url = productVendor?.app_url;
+      logger.info('found vendor url', { url, productVendor });
+
+      if (url) {
+        const vendorMeta = await getBlockletJson(url);
+        const mountPoint = vendorMeta.componentMountPoints?.find((x: any) => x.appId === vendorId)?.mountPoint;
+        const serverStatusUrl = joinURL(url, mountPoint, '/api/vendor/status', vendor.order_id);
+
+        const result = await fetch(serverStatusUrl);
+        const data = await result.json();
+        vendor.app_url = data?.appUrl || '';
+      }
+    }
+
+    logger.info('checkOrderStatus', { vendor });
+    const adapter = await VendorAdapterFactory.create(vendor.vendor_key);
+    const result = await adapter.checkOrderStatus({ appUrl: vendor.app_url });
+
+    if (result.status === 'completed') {
+      vendor.status = 'completed';
+      vendor.lastAttemptAt = new Date().toISOString();
+    } else if (result.status === 'failed') {
+      vendor.status = 'failed';
+      vendor.lastAttemptAt = new Date().toISOString();
+    } else if (result.status === 'processing') {
+      vendor.status = 'processing';
+      vendor.lastAttemptAt = new Date().toISOString();
+    }
+  } catch (error) {
+    logger.warn('Failed to check vendor status', {
+      checkoutSessionId,
+      vendorId,
+      error: error.message,
+    });
+  }
+
+  const vendorInfo = checkoutSession?.vendor_info?.map((v) => {
+    if (v.vendor_id === vendorId) {
+      v.app_url = vendor.app_url || '';
+      vendor.app_url = vendor.app_url || '';
+      vendor.status = vendor.status || 'sent';
+    }
+    return v;
+  });
+
+  logger.info('update vendor info', { vendorInfo });
+
+  await CheckoutSession.update(
+    {
+      vendor_info: vendorInfo,
+    },
+    { where: { id: checkoutSessionId } }
+  );
+
+  if (vendor.status === 'completed' || vendor.status === 'failed') {
+    fulfillmentCoordinatorQueue.push({
+      id: `fulfillment-coordinator-${checkoutSessionId}-${vendorId}`,
+      job: {
+        checkoutSessionId,
+        paymentIntentId: checkoutSession?.payment_intent_id || '',
+        triggeredBy: 'vendor-status-check',
+      },
+    });
+  }
+
+  return { status: vendor.status };
+};
+
+type VendorStatusCheckJob = {
+  checkoutSessionId: string;
+  vendorId: string;
+};
+
+export const vendorStatusCheckQueue = createQueue<VendorStatusCheckJob>({
+  name: 'vendor-status-check',
+  onJob: handleVendorStatusCheck,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});

package/api/src/routes/checkout-sessions.ts

@@ -824,6 +824,7 @@ router.post('/', authLogin, async (req, res) => {
 });
 
 export async function startCheckoutSessionFromPaymentLink(id: string, req: Request, res: Response) {
+  const { metadata } = req.body;
   try {
     const link = await PaymentLink.findByPk(id);
     if (!link) {
@@ -942,6 +943,7 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
         raw.metadata = {
           ...link.metadata,
           ...getDataObjectFromQuery(req.query),
+          ...metadata,
           days_until_due: getDaysUntilDue(req.query),
           days_until_cancel: getDaysUntilCancel(req.query),
           passport: await checkPassportForPaymentLink(link),
@@ -952,6 +954,7 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
       raw.metadata = {
         ...link.metadata,
         ...getDataObjectFromQuery(req.query),
+        ...metadata,
         days_until_due: getDaysUntilDue(req.query),
         days_until_cancel: getDaysUntilCancel(req.query),
         passport: await checkPassportForPaymentLink(link),

package/api/src/routes/index.ts

@@ -30,6 +30,7 @@ import subscriptions from './subscriptions';
 import usageRecords from './usage-records';
 import webhookAttempts from './webhook-attempts';
 import webhookEndpoints from './webhook-endpoints';
+import vendor from './vendor';
 
 const router = Router();
 
@@ -81,5 +82,6 @@ router.use('/subscriptions', subscriptions);
 router.use('/usage-records', usageRecords);
 router.use('/webhook-attempts', webhookAttempts);
 router.use('/webhook-endpoints', webhookEndpoints);
+router.use('/vendors', vendor);
 
 export default router;

package/api/src/routes/products.ts

@@ -12,6 +12,8 @@ import { formatMetadata } from '../libs/util';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
+import { ProductVendor } from '../store/models/product-vendor';
+
 import type { CustomUnitAmount } from '../store/models/types';
 import { checkCurrencySupportRecurring } from '../libs/product';
 
@@ -19,6 +21,16 @@ const router = Router();
 
 const auth = authenticate<Product>({ component: true, roles: ['owner', 'admin'] });
 
+const VendorConfigSchema = Joi.array()
+  .items(
+    Joi.object({
+      vendor_id: Joi.string().required(),
+      commission_rate: Joi.number().min(0).max(100).required(),
+      commission_type: Joi.string().valid('percentage', 'fixed').required(),
+    }).unknown(true)
+  )
+  .optional();
+
 const ProductAndPriceSchema = Joi.object({
   name: Joi.string().max(64).empty('').optional(),
   type: Joi.string().valid('service', 'good', 'credit').empty('').optional(),
@@ -55,6 +67,7 @@ const ProductAndPriceSchema = Joi.object({
       }).unknown(true)
     )
     .optional(),
+  vendor_config: VendorConfigSchema,
 }).unknown(true);
 
 const CreditConfigSchema = Joi.object({
@@ -67,7 +80,6 @@ const CreditConfigSchema = Joi.object({
 });
 
 export async function createProductAndPrices(payload: any) {
-  // 1. 准备 product 数据
   const raw: Partial<Product> = pick(payload, [
     'name',
     'type',
@@ -80,6 +92,36 @@ export async function createProductAndPrices(payload: any) {
     'features',
     'metadata',
   ]);
+
+  if (Array.isArray(payload.vendor_config) && payload.vendor_config.length > 0) {
+    // validate vendor_config data
+    const { error: vendorConfigError } = VendorConfigSchema.validate(payload.vendor_config);
+    if (vendorConfigError) {
+      throw new Error(`vendor_config validation failed: ${vendorConfigError.message}`);
+    }
+
+    const vendorConfigs = await ProductVendor.findAll({
+      where: {
+        id: payload.vendor_config.map((x: any) => x.vendor_id),
+      },
+    });
+
+    raw.vendor_config = payload.vendor_config.map((config: any) => {
+      const vendorConfig = vendorConfigs.find((x) => x.id === config.vendor_id);
+      if (!vendorConfig) {
+        throw new Error(`vendor ${config.vendor_id} not found`);
+      }
+      return {
+        vendor_id: vendorConfig.id,
+        vendor_key: vendorConfig.vendor_key,
+        name: vendorConfig.name,
+        description: vendorConfig.description,
+        commission_rate: Number(config.commission_rate),
+        commission_type: config.commission_type === 'fixed' ? 'fixed_amount' : config.commission_type,
+        custom_params: {},
+      };
+    });
+  }
   raw.active = true;
   raw.type = raw.type || 'service';
   raw.livemode = !!payload.livemode;
@@ -389,6 +431,35 @@ router.put('/:id', auth, async (req, res) => {
     'metadata',
     'cross_sell',
   ]);
+
+  if (Array.isArray(req.body.vendor_config)) {
+    const { error: vendorConfigError } = VendorConfigSchema.validate(req.body.vendor_config);
+    if (vendorConfigError) {
+      return res.status(400).json({ error: `vendor_config validation failed: ${vendorConfigError.message}` });
+    }
+
+    const vendorConfigs = await ProductVendor.findAll({
+      where: {
+        id: req.body.vendor_config.map((x: any) => x.vendor_id),
+      },
+    });
+
+    updates.vendor_config = req.body.vendor_config.map((config: any) => {
+      const vendorConfig = vendorConfigs.find((x) => x.id === config.vendor_id);
+      if (!vendorConfig) {
+        throw new Error(`vendor ${config.vendor_id} not found`);
+      }
+      return {
+        vendor_id: vendorConfig.id,
+        vendor_key: vendorConfig.vendor_key,
+        name: vendorConfig.name,
+        description: vendorConfig.description,
+        commission_rate: Number(config.commission_rate),
+        commission_type: config.commission_type === 'fixed' ? 'fixed_amount' : config.commission_type,
+        custom_params: {},
+      };
+    });
+  }
   const { error } = ProductAndPriceSchema.validate(updates);
   if (error) {
     return res.status(400).json({ error: `Product update request invalid: ${error.message}` });