payment-kit 1.20.20 → 1.20.21

package/api/src/integrations/stripe/resource.ts

@@ -579,7 +579,7 @@ async function createStripeSubscriptionCoupon(
     id: existingCouponId, // Use predictable ID
     name: `sub_coupon_${localCoupon.id}`,
     duration: localCoupon.duration as 'once' | 'forever' | 'repeating',
-    max_redemptions: 1, // Limit to this subscription only
+    redeem_by: Math.floor((new Date().getTime() + 24 * 60 * 60 * 1000) / 1000),
     metadata: {
       appPid: env.appPid,
       local_coupon_id: localCoupon.id,

package/api/src/libs/discount/coupon.ts

@@ -264,7 +264,7 @@ function buildBaseDiscountData({
   checkoutSession: CheckoutSession;
   customerId: string;
   coupon: Coupon;
-  promotionCode: PromotionCode;
+  promotionCode?: PromotionCode;
   discountAmount: string;
   verificationData?: any;
 }) {
@@ -282,18 +282,18 @@ function buildBaseDiscountData({
   return {
     livemode: coupon.livemode,
     coupon_id: coupon.id,
-    promotion_code_id: promotionCode.id,
+    promotion_code_id: promotionCode?.id,
     customer_id: customerId,
     checkout_session_id: checkoutSession.id,
     start: now,
     end: endTime,
-    verification_method: promotionCode.verification_type,
+    verification_method: promotionCode?.verification_type,
     verification_data: verificationData || checkoutSession.metadata?.verification_data,
     metadata: {
-      checkout_session_id: checkoutSession.id,
       discount_amount: discountAmount,
       original_amount: checkoutSession.amount_subtotal,
       final_amount: checkoutSession.amount_total,
+      currency_id: checkoutSession.currency_id,
       applied_at: new Date().toISOString(),
     },
   };
@@ -317,41 +317,23 @@ async function processSubscriptionDiscount({
     const existingDiscount = existingDiscountMap.get(subscriptionId);
 
     if (existingDiscount) {
-      // Check if coupon or promotion code has changed
-      if (
-        existingDiscount.coupon_id !== baseDiscountData.coupon_id ||
-        existingDiscount.promotion_code_id !== baseDiscountData.promotion_code_id
-      ) {
-        // Update existing discount record
-        await existingDiscount.update({
-          ...baseDiscountData,
-          subscription_id: subscriptionId,
-          metadata: {
-            ...baseDiscountData.metadata,
-            subscription_id: subscriptionId,
-            updated_at: new Date().toISOString(),
-          },
-        });
-
-        logger.info('Updated existing discount record for subscription', {
-          checkoutSessionId,
-          subscriptionId,
-          discountId: existingDiscount.id,
-          oldCouponId: existingDiscount.coupon_id,
-          newCouponId: baseDiscountData.coupon_id,
-        });
+      const couponChanged = existingDiscount.coupon_id !== baseDiscountData.coupon_id;
+      const promoChanged = existingDiscount.promotion_code_id !== baseDiscountData.promotion_code_id;
 
-        return { discountRecord: existingDiscount, shouldUpdateUsage: true };
-      }
+      const updated = await existingDiscount.update({
+        ...baseDiscountData,
+        subscription_id: subscriptionId,
+      });
 
-      // Same coupon/promotion code, no update needed
-      logger.debug('Discount record already exists with same coupon/promotion', {
+      logger.info('Upserted discount record for subscription', {
         checkoutSessionId,
         subscriptionId,
-        discountId: existingDiscount.id,
+        discountId: updated.id,
+        couponChanged,
+        promoChanged,
       });
 
-      return { discountRecord: existingDiscount, shouldUpdateUsage: false };
+      return { discountRecord: updated, shouldUpdateUsage: couponChanged || promoChanged };
     }
 
     // Create new discount record
@@ -397,35 +379,21 @@ async function processNonSubscriptionDiscount(
     const existingDiscount = existingDiscountMap.get('no_subscription');
 
     if (existingDiscount) {
-      if (
-        existingDiscount.coupon_id !== baseDiscountData.coupon_id ||
-        existingDiscount.promotion_code_id !== baseDiscountData.promotion_code_id
-      ) {
-        // Update existing discount record
-        await existingDiscount.update({
-          ...baseDiscountData,
-          metadata: {
-            ...baseDiscountData.metadata,
-            updated_at: new Date().toISOString(),
-          },
-        });
-
-        logger.info('Updated existing discount record', {
-          checkoutSessionId,
-          discountId: existingDiscount.id,
-          oldCouponId: existingDiscount.coupon_id,
-          newCouponId: baseDiscountData.coupon_id,
-        });
+      const couponChanged = existingDiscount.coupon_id !== baseDiscountData.coupon_id;
+      const promoChanged = existingDiscount.promotion_code_id !== baseDiscountData.promotion_code_id;
 
-        return { discountRecord: existingDiscount, shouldUpdateUsage: true };
-      }
+      const updated = await existingDiscount.update({
+        ...baseDiscountData,
+      });
 
-      logger.debug('Discount record already exists with same coupon/promotion', {
+      logger.info('Upserted single discount record', {
         checkoutSessionId,
-        discountId: existingDiscount.id,
+        discountId: updated.id,
+        couponChanged,
+        promoChanged,
       });
 
-      return { discountRecord: existingDiscount, shouldUpdateUsage: false };
+      return { discountRecord: updated, shouldUpdateUsage: couponChanged || promoChanged };
     }
 
     // Create new discount record
@@ -464,17 +432,17 @@ async function updateUsageCounts({
   checkoutSessionId,
 }: {
   coupon: Coupon;
-  promotionCode: PromotionCode;
+  promotionCode?: PromotionCode;
   updatedCoupons: Set<string>;
   updatedPromotionCodes: Set<string>;
   checkoutSessionId: string;
 }): Promise<void> {
   try {
-    const updatePromises = [];
+    const updatePromises = [] as Array<Promise<any>>;
 
     // Create unique keys based on checkout session to prevent duplicate counting
     const couponSessionKey = `${coupon.id}-${checkoutSessionId}`;
-    const promotionCodeSessionKey = `${promotionCode.id}-${checkoutSessionId}`;
+    const promotionCodeSessionKey = promotionCode ? `${promotionCode.id}-${checkoutSessionId}` : '';
 
     if (!updatedCoupons.has(couponSessionKey)) {
       updatedCoupons.add(couponSessionKey);
@@ -485,7 +453,7 @@ async function updateUsageCounts({
       );
     }
 
-    if (!updatedPromotionCodes.has(promotionCodeSessionKey)) {
+    if (promotionCode && promotionCodeSessionKey && !updatedPromotionCodes.has(promotionCodeSessionKey)) {
       updatedPromotionCodes.add(promotionCodeSessionKey);
       updatePromises.push(
         promotionCode.update({
@@ -496,18 +464,20 @@ async function updateUsageCounts({
 
     await Promise.all(updatePromises);
     emitAsync('discount-status.queued', coupon, 'coupon', true);
-    emitAsync('discount-status.queued', promotionCode, 'promotion-code', true);
+    if (promotionCode) {
+      emitAsync('discount-status.queued', promotionCode, 'promotion-code', true);
+    }
 
     logger.debug('Updated coupon and promotion code usage counts', {
       checkoutSessionId,
       couponId: coupon.id,
-      promotionCodeId: promotionCode.id,
+      promotionCodeId: promotionCode?.id,
     });
   } catch (error) {
     logger.error('Error updating usage counts', {
       checkoutSessionId,
       couponId: coupon.id,
-      promotionCodeId: promotionCode.id,
+      promotionCodeId: promotionCode?.id,
       error: error.message,
     });
     throw new Error(`Failed to update usage counts: ${error.message}`);
@@ -630,10 +600,9 @@ export async function createDiscountRecordsForCheckout({
     const discountProcessingPromises = checkoutSession.discounts.map(async (discount: any) => {
       const { promotion_code: promotionCodeId, coupon: couponId, discount_amount: discountAmount } = discount;
 
-      if (!promotionCodeId || !couponId) {
+      if (!couponId) {
         logger.warn('Incomplete discount configuration, skipping', {
           checkoutSessionId: checkoutSession.id,
-          hasPromotionCode: !!promotionCodeId,
           hasCoupon: !!couponId,
         });
         return null;
@@ -643,13 +612,12 @@ export async function createDiscountRecordsForCheckout({
         // Fetch coupon and promotion code
         const [coupon, promotionCode] = await Promise.all([
           Coupon.findByPk(couponId),
-          PromotionCode.findByPk(promotionCodeId),
+          promotionCodeId ? PromotionCode.findByPk(promotionCodeId) : Promise.resolve(null),
         ]);
 
-        if (!coupon || !promotionCode) {
-          logger.warn('Coupon or promotion code not found, skipping discount', {
+        if (!coupon) {
+          logger.warn('Coupon not found, skipping discount', {
             couponId,
-            promotionCodeId,
             checkoutSessionId: checkoutSession.id,
           });
           return null;
@@ -660,7 +628,7 @@ export async function createDiscountRecordsForCheckout({
           checkoutSession,
           customerId,
           coupon,
-          promotionCode,
+          promotionCode: promotionCode || undefined,
           discountAmount,
           verificationData: discount.verification_data,
         });
@@ -725,7 +693,7 @@ export async function createDiscountRecordsForCheckout({
           try {
             await updateUsageCounts({
               coupon,
-              promotionCode,
+              promotionCode: promotionCode || undefined,
               updatedCoupons,
               updatedPromotionCodes,
               checkoutSessionId: checkoutSession.id,
@@ -740,7 +708,7 @@ export async function createDiscountRecordsForCheckout({
           } catch (error) {
             logger.error('Failed to update usage counts, but continuing', {
               couponId: coupon.id,
-              promotionCodeId: promotionCode.id,
+              promotionCodeId: promotionCode?.id,
               error: error.message,
             });
           }

package/api/src/libs/invoice.ts

@@ -1386,3 +1386,20 @@ export const migrateSubscriptionPaymentMethodInvoice = async (
     throw error;
   }
 };
+
+export async function destroyExistingInvoice(invoice: Invoice) {
+  const paymentMethod = await PaymentMethod.findByPk(invoice.default_payment_method_id);
+  try {
+    if (paymentMethod?.type === 'stripe' && invoice.metadata?.stripe_id) {
+      const client = paymentMethod.getStripeClient();
+      await client.invoices.del(invoice.metadata.stripe_id);
+    }
+  } catch (error) {
+    logger.error('Failed to destroy invoice on stripe', {
+      error: error.message,
+      invoiceId: invoice.id,
+    });
+  }
+  await InvoiceItem.destroy({ where: { invoice_id: invoice.id } });
+  await invoice.destroy();
+}

package/api/src/libs/notification/template/subscription-renew-failed.ts

@@ -20,7 +20,7 @@ import { PaymentCurrency } from '../../../store/models/payment-currency';
 import { getCustomerInvoicePageUrl } from '../../invoice';
 import { SufficientForPaymentResult, getPaymentDetail } from '../../payment';
 import { getMainProductName } from '../../product';
-import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { getCustomerSubscriptionPageUrl, getSubscriptionPaymentAddress } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
 import { formatCurrencyInfo, getExplorerLink, getSubscriptionNotificationCustomActions } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
@@ -47,6 +47,7 @@ interface SubscriptionRenewFailedEmailTemplateContext {
   viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
   customActions: any[];
+  payer: string;
 }
 
 export class SubscriptionRenewFailedEmailTemplate
@@ -166,6 +167,8 @@ export class SubscriptionRenewFailedEmailTemplate
       viewInvoiceLink,
       viewTxHashLink,
       customActions,
+      payer:
+        paymentMethod?.type !== 'stripe' && getSubscriptionPaymentAddress(subscription, paymentMethod?.type as string),
     };
   }
 
@@ -185,6 +188,7 @@ export class SubscriptionRenewFailedEmailTemplate
       viewInvoiceLink,
       viewTxHashLink,
       customActions,
+      payer,
     } = await this.getContext();
 
     const template: BaseEmailTemplateType = {
@@ -230,6 +234,23 @@ export class SubscriptionRenewFailedEmailTemplate
                 text: productName,
               },
             },
+            ...(payer && [
+              {
+                type: 'text',
+                data: {
+                  type: 'plain',
+                  color: '#9397A1',
+                  text: translate('notification.common.payer', locale),
+                },
+              },
+              {
+                type: 'text',
+                data: {
+                  type: 'plain',
+                  text: payer,
+                },
+              },
+            ]),
             {
               type: 'text',
               data: {

package/api/src/libs/notification/template/subscription-will-renew.ts

@@ -40,6 +40,7 @@ interface SubscriptionWillRenewEmailTemplateContext {
   isCreditSubscription: boolean;
   isStripe: boolean;
   isMetered: boolean;
+  payer: string;
 }
 
 export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTemplate<SubscriptionWillRenewEmailTemplateContext> {
@@ -159,6 +160,9 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
       isCreditSubscription,
       isStripe,
       isMetered: !isPrePaid,
+      payer:
+        paymentInfoResult.paymentMethod?.type !== 'stripe' &&
+        getSubscriptionPaymentAddress(subscription, paymentInfoResult.paymentMethod!.type),
     };
   }
 
@@ -210,6 +214,7 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
       isCreditSubscription,
       isStripe,
       isMetered,
+      payer,
     } = context;
 
     // 如果当前时间大于预计扣费时间，那么不发送通知
@@ -385,6 +390,23 @@ export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTem
           type: 'section',
           fields: [
             ...commonFields,
+            ...(payer && [
+              {
+                type: 'text',
+                data: {
+                  type: 'plain',
+                  color: '#9397A1',
+                  text: translate('notification.common.payer', locale),
+                },
+              },
+              {
+                type: 'text',
+                data: {
+                  type: 'plain',
+                  text: payer,
+                },
+              },
+            ]),
             ...renewAmountFields,
             ...balanceFields,
             ...insufficientBalanceFields,

package/api/src/locales/en.ts

@@ -50,6 +50,7 @@ export default flat({
       billedAmount: 'Billed amount',
       viewCreditGrant: 'View Credit Balance',
       invoiceNumber: 'Invoice Number',
+      payer: 'Payer',
     },
 
     billingDiscrepancy: {

package/api/src/locales/zh.ts

@@ -50,6 +50,7 @@ export default flat({
       billedAmount: '实缴金额',
       viewCreditGrant: '查看额度',
       invoiceNumber: '账单编号',
+      payer: '付款方',
     },
 
     sendTo: '发送给',

package/api/src/queues/checkout-session.ts

@@ -22,6 +22,7 @@ import {
 } from '../store/models';
 import { getCheckoutSessionSubscriptionIds } from '../libs/session';
 import { rollbackDiscountUsageForCheckoutSession } from '../libs/discount/discount';
+import { destroyExistingInvoice } from '../libs/invoice';
 
 type CheckoutSessionJob = {
   id: string;
@@ -147,8 +148,7 @@ events.on('checkout.session.expired', async (checkoutSession: CheckoutSession) =
     // Do some reverse lookup if invoice is not related to checkout session
     const invoice = await Invoice.findOne({ where: { checkout_session_id: checkoutSession.id } });
     if (invoice) {
-      await InvoiceItem.destroy({ where: { invoice_id: invoice.id } });
-      await Invoice.destroy({ where: { id: invoice.id } });
+      await destroyExistingInvoice(invoice);
       logger.info('Invoice and InvoiceItem for checkout session deleted on expire', {
         checkoutSession: checkoutSession.id,
         invoice: invoice.id,

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

@@ -107,6 +107,7 @@ import {
 } from '../libs/discount/coupon';
 import { rollbackDiscountUsageForCheckoutSession, applyDiscountsToLineItems } from '../libs/discount/discount';
 import { formatToShortUrl } from '../libs/url';
+import { destroyExistingInvoice } from '../libs/invoice';
 
 const router = Router();
 
@@ -1200,6 +1201,76 @@ router.get('/:id', auth, async (req, res) => {
   }
 });
 
+// abort stripe subscription(s) created during an incomplete checkout session
+router.post('/:id/abort-stripe', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+
+    if (checkoutSession.status === 'complete') {
+      return res.status(400).json({ error: 'Checkout session already completed' });
+    }
+
+    // cancel stripe subscriptions if any
+    const canceledSubscriptions: string[] = [];
+    if (['subscription', 'setup'].includes(checkoutSession.mode)) {
+      const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+      const subscriptions = await Subscription.findAll({ where: { id: subscriptionIds } });
+
+      const cancelOps = subscriptions.map(async (sub) => {
+        const stripeSubId = sub.payment_details?.stripe?.subscription_id;
+        if (!stripeSubId) {
+          return null;
+        }
+        const method = await PaymentMethod.findByPk(sub.default_payment_method_id);
+        if (!method || method.type !== 'stripe') {
+          return null;
+        }
+        const client = method.getStripeClient();
+        try {
+          await client.subscriptions.cancel(stripeSubId);
+          await sub.update({
+            payment_details: omit(sub.payment_details || {}, 'stripe'),
+            payment_settings: {
+              payment_method_options: omit(sub.payment_settings?.payment_method_options || {}, 'stripe'),
+              payment_method_types: sub.payment_settings?.payment_method_types || [],
+            },
+          });
+          canceledSubscriptions.push(sub.id);
+        } catch (err) {
+          logger.error('Failed to cancel stripe subscription for checkout abort', {
+            checkoutSessionId: checkoutSession.id,
+            subscriptionId: sub.id,
+            error: err.message,
+          });
+        }
+        return sub.id;
+      });
+      await Promise.all(cancelOps);
+    }
+
+    // remove related invoice if created
+    try {
+      const existInvoice = await Invoice.findOne({ where: { checkout_session_id: checkoutSession.id } });
+      if (existInvoice && existInvoice.status === 'paid') {
+        await destroyExistingInvoice(existInvoice);
+      }
+    } catch (error: any) {
+      logger.error('Failed to destroy invoice on checkout abort', {
+        checkoutSessionId: checkoutSession.id,
+        error: error.message,
+      });
+    }
+    res.json({ checkoutSessionId: checkoutSession.id, canceledSubscriptions });
+  } catch (err: any) {
+    logger.error('Error aborting stripe for checkout session', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
+    res.status(500).json({ error: err.message });
+  }
+});
+
 // for checkout page
 router.get('/retrieve/:id', user, async (req, res) => {
   const doc = await CheckoutSession.findByPk(req.params.id);
@@ -1436,6 +1507,19 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       amount: checkoutSession.amount_subtotal,
     });
 
+    // destroy exist invoice if currency is not aligned
+    try {
+      const existInvoice = await Invoice.findOne({ where: { checkout_session_id: checkoutSession.id } });
+      if (existInvoice && existInvoice.currency_id !== paymentCurrency.id) {
+        await destroyExistingInvoice(existInvoice);
+      }
+    } catch (err) {
+      logger.error('Failed to destroy exist invoice', {
+        error: err.message,
+        checkoutSessionId: checkoutSession.id,
+      });
+    }
+
     // create or update payment intent
     let paymentIntent: PaymentIntent | null = null;
     if (checkoutSession.mode === 'payment') {

package/api/src/routes/connect/collect-batch.ts

@@ -31,7 +31,7 @@ export default {
   },
   onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
     const { subscriptionId, currencyId, customerId } = extraParams;
-    const { amount, invoices, paymentCurrency, paymentMethod } = await ensureSubscriptionForCollectBatch(
+    const { amount, invoices, paymentCurrency, paymentMethod, subscription } = await ensureSubscriptionForCollectBatch(
       subscriptionId,
       currencyId,
       customerId
@@ -52,7 +52,7 @@ export default {
       const claims: { [key: string]: object } = {
         prepareTx: {
           type: 'TransferV3Tx',
-          description: `Pay all past due invoices for ${subscriptionId}`,
+          description: `Pay all past due invoices for subscription ${subscription?.description}`,
           partialTx: { from: userDid, pk: userPk, itx },
           requirement: { tokens },
           chainInfo: {

package/api/src/routes/connect/pay.ts

@@ -54,7 +54,7 @@ export default {
       return {
         prepareTx: {
           type: 'TransferV3Tx',
-          description: `Approve the transfer to complete payment ${paymentIntent.id}`,
+          description: 'Approve the transfer to complete payment',
           partialTx: { from: userDid, pk: userPk, itx },
           requirement: { tokens },
           chainInfo: {

package/api/src/store/migrations/20250926-change-customer-did-unique.ts

@@ -0,0 +1,49 @@
+/* eslint-disable no-console */
+import { DataTypes, QueryTypes } from 'sequelize';
+import { Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  try {
+    await context.changeColumn('customers', 'did', {
+      type: DataTypes.STRING(40),
+      allowNull: false,
+      unique: true,
+    });
+
+    console.log('Successfully added unique constraint to customers.did');
+  } catch (error) {
+    try {
+      const duplicates = await context.sequelize.query(
+        `SELECT did, COUNT(*) as count 
+         FROM customers 
+         GROUP BY did 
+         HAVING COUNT(*) > 1
+         LIMIT 5`,
+        { type: QueryTypes.SELECT }
+      );
+
+      if (duplicates.length > 0) {
+        console.warn('Found duplicate DIDs in customers table (showing first 5):', duplicates);
+        console.warn('Skipping unique constraint addition. Please clean up duplicate data manually if needed.');
+      } else {
+        console.error('Failed to add unique constraint for unknown reason:', error.message);
+      }
+    } catch (checkError) {
+      console.error('Failed to check for duplicates:', checkError.message);
+    }
+  }
+};
+
+export const down: Migration = async ({ context }) => {
+  try {
+    await context.changeColumn('customers', 'did', {
+      type: DataTypes.STRING(40),
+      allowNull: false,
+      unique: false,
+    });
+
+    console.log('Successfully removed unique constraint from customers.did');
+  } catch (error) {
+    console.warn('Failed to remove unique constraint from customers.did:', error.message);
+  }
+};

package/api/src/store/models/customer.ts

@@ -81,6 +81,7 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
     did: {
       type: DataTypes.STRING(40),
       allowNull: false,
+      unique: true,
     },
     address: {
       type: DataTypes.JSON,