payment-kit 1.20.10 → 1.20.12

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

@@ -43,6 +43,8 @@ import {
   getSubscriptionLineItems,
   isCreditMeteredLineItems,
   validatePaymentAmounts,
+  processCheckoutSessionDiscounts,
+  getCheckoutSessionAmounts,
 } from '../libs/session';
 import { getDaysUntilCancel, getDaysUntilDue, getSubscriptionTrialSetup } from '../libs/subscription';
 import {
@@ -65,6 +67,8 @@ import {
   type TProductExpanded,
   type TLineItemExpanded,
   Invoice,
+  Coupon,
+  PromotionCode,
 } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -94,7 +98,15 @@ import { CHARGE_SUPPORTED_CHAIN_TYPES } from '../libs/constants';
 import { blocklet } from '../libs/auth';
 import { addSubscriptionJob } from '../queues/subscription';
 import { updateDataConcurrency } from '../libs/env';
+import {
+  expandLineItemsWithCouponInfo,
+  expandDiscountsWithDetails,
+  checkPromotionCodeEligibility,
+  createDiscountRecordsForCheckout,
+  updateSubscriptionDiscountReferences,
+} from '../libs/discount/coupon';
 import { formatToShortUrl } from '../libs/url';
+import { applyDiscountsToLineItems } from '../libs/discount/discount';
 
 const router = Router();
 
@@ -184,7 +196,87 @@ export async function validatePaymentSettings(paymentMethodId: string, paymentCu
 }
 
 /**
- * 计算并更新支付金额
+ * Validate promotion codes are still valid during checkout submission
+ * Uses unified eligibility check to avoid duplicate validation
+ */
+async function validatePromotionCodesOnSubmit(
+  checkoutSession: CheckoutSession,
+  {
+    lineItems,
+    customerId,
+    amount,
+  }: {
+    lineItems: TLineItemExpanded[];
+    customerId: string;
+    amount?: string;
+  }
+) {
+  if (!checkoutSession.discounts?.length) {
+    return;
+  }
+
+  logger.info('Validating promotion codes on checkout submission', {
+    checkoutSessionId: checkoutSession.id,
+    discountCount: checkoutSession.discounts.length,
+    customerId,
+  });
+
+  const validationPromises = checkoutSession.discounts.map(async (discount, index) => {
+    const { promotion_code: promotionCodeId, coupon: couponId } = discount;
+
+    if (!promotionCodeId || !couponId) {
+      logger.warn('Incomplete discount configuration', {
+        checkoutSessionId: checkoutSession.id,
+        discountIndex: index,
+        hasPromotionCode: !!promotionCodeId,
+        hasCoupon: !!couponId,
+      });
+      return;
+    }
+
+    // Fetch promotion code
+    const promotionCode = await PromotionCode.findByPk(promotionCodeId);
+    if (!promotionCode) {
+      throw new CustomError(400, 'Promotion code not found');
+    }
+
+    // Use unified eligibility check - this includes all validations
+    const eligibilityCheck = await checkPromotionCodeEligibility({
+      promotionCode,
+      couponId,
+      customerId: customerId || checkoutSession.customer_id || '',
+      amount: amount || checkoutSession.amount_total,
+      currencyId: checkoutSession.currency_id || '',
+      lineItems,
+    });
+
+    if (!eligibilityCheck.eligible) {
+      logger.warn('Promotion code validation failed', {
+        checkoutSessionId: checkoutSession.id,
+        promotionCodeId,
+        couponId,
+        reason: eligibilityCheck.reason,
+      });
+      throw new CustomError(400, eligibilityCheck.reason || 'Promotion code is no longer valid');
+    }
+
+    logger.debug('Promotion code validation passed', {
+      checkoutSessionId: checkoutSession.id,
+      promotionCodeId,
+      couponId,
+    });
+  });
+
+  await Promise.all(validationPromises);
+
+  logger.info('All promotion codes validated successfully', {
+    checkoutSessionId: checkoutSession.id,
+    validatedCount: checkoutSession.discounts.length,
+  });
+}
+
+/**
+ * Calculate and update payment amount for checkout session
  */
 export async function calculateAndUpdateAmount(
   checkoutSession: CheckoutSession,
@@ -204,7 +296,38 @@ export async function calculateAndUpdateAmount(
     trialEnd = trialSetup.trialEnd;
   }
 
-  const amount = getCheckoutAmount(lineItems, paymentCurrencyId, trialInDays > 0 || trialEnd > now);
+  // Prepare discount configuration for getCheckoutAmount
+  let discountConfig;
+  if (checkoutSession.discounts && checkoutSession.discounts.length > 0) {
+    const firstDiscount = checkoutSession.discounts[0];
+    if (firstDiscount?.coupon) {
+      discountConfig = {
+        couponId: firstDiscount.coupon,
+      };
+    }
+    if (firstDiscount?.promotion_code) {
+      discountConfig = {
+        ...discountConfig,
+        promotionCodeId: firstDiscount.promotion_code,
+      };
+    }
+    if (checkoutSession.customer_id) {
+      discountConfig = {
+        ...discountConfig,
+        customerId: checkoutSession.customer_id,
+      };
+    }
+  }
+
+  logger.info('Getting checkout amount', {
+    discountConfig,
+  });
+  const amount = await getCheckoutAmount(
+    lineItems,
+    paymentCurrencyId,
+    trialInDays > 0 || trialEnd > now,
+    discountConfig
+  );
 
   await checkoutSession.update({
     amount_subtotal: amount.subtotal,
@@ -216,11 +339,22 @@ export async function calculateAndUpdateAmount(
     },
   });
 
-  if (checkoutSession.mode === 'payment' && amount.total <= 0) {
-    throw new Error('Payment amount should be greater than 0');
+  logger.info('Amount calculated', {
+    checkoutSessionId: checkoutSession.id,
+    amount,
+  });
+
+  if (checkoutSession.mode === 'payment' && amount.total < 0) {
+    throw new Error('Payment amount should be greater or equal to 0');
   }
 
-  return { lineItems, amount, trialInDays, trialEnd, now };
+  return {
+    lineItems: amount.processedItems || lineItems,
+    amount,
+    trialInDays,
+    trialEnd,
+    now,
+  };
 }
 
 /**
@@ -399,6 +533,14 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
       submit_type: 'pay',
       cross_sell_behavior: 'auto',
       enable_subscription_grouping: false,
+      // Ensure required amount fields are never null
+      amount_subtotal: '0',
+      amount_total: '0',
+      total_details: {
+        amount_discount: '0',
+        amount_shipping: '0',
+        amount_tax: '0',
+      },
     },
     pick(payload, [
       'currency_id',
@@ -422,6 +564,8 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
       'client_reference_id',
       'after_expiration',
       'enable_subscription_grouping',
+      'promotion_code',
+      'discounts',
     ])
   );
 
@@ -502,23 +646,6 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
   });
 };
 
-export async function getCheckoutSessionAmounts(checkoutSession: CheckoutSession) {
-  const now = dayjs().unix();
-  const items = await Price.expand(checkoutSession.line_items);
-  const trialInDays = Number(checkoutSession.subscription_data?.trial_period_days || 0);
-  const trialEnd = Number(checkoutSession.subscription_data?.trial_end || 0);
-  const amount = getCheckoutAmount(items, checkoutSession.currency_id, trialInDays > 0 || trialEnd > now);
-  return {
-    amount_subtotal: amount.subtotal,
-    amount_total: amount.total,
-    total_details: {
-      amount_discount: amount.discount,
-      amount_shipping: amount.shipping,
-      amount_tax: amount.tax,
-    },
-  };
-}
-
 export async function ensureCheckoutSessionOpen(req: Request, res: Response, next: NextFunction) {
   const doc = await CheckoutSession.findByPk(req.params.id);
   if (!doc) {
@@ -635,7 +762,20 @@ async function processSubscriptionFastCheckout({
     const subscriptionAmounts = await pAll(
       subscriptions.map((sub) => async () => {
         const subItems = await getSubscriptionLineItems(sub, lineItems, primarySubscription);
-        return getFastCheckoutAmount(subItems, 'subscription', paymentCurrency.id, trialEnd > now);
+        const discountConfig = {
+          promotionCodeId: checkoutSession.discounts?.[0]?.promotion_code,
+          couponId: checkoutSession.discounts?.[0]?.coupon,
+          customerId: checkoutSession.customer_id,
+        };
+        const amount = await getFastCheckoutAmount({
+          items: subItems,
+          mode: 'subscription',
+          currencyId: paymentCurrency.id,
+          trialing: trialEnd > now,
+          minimumCycle: 1,
+          discountConfig,
+        });
+        return amount;
       }),
       { concurrency: updateDataConcurrency }
     );
@@ -689,10 +829,11 @@ async function processSubscriptionFastCheckout({
       );
       if (paymentCurrency.isCredit()) {
         // skip invoice creation for credit subscriptions
-        checkoutSession.update({
+        await checkoutSession.update({
           status: 'complete',
           payment_status: 'paid',
         });
+
         await pAll(
           subscriptions.map((sub) => async () => {
             await sub.update({
@@ -783,6 +924,8 @@ router.post('/', authLogin, async (req, res) => {
     // Customer permission validation and createMine handling
     const { create_mine: createMine } = req.body;
     const currentUserDid = req.user?.did;
+
+    const isAdmin = ['owner', 'admin'].includes(req.user?.role as string);
     // Handle createMine parameter
     if (createMine === true) {
       if (!currentUserDid) {
@@ -798,7 +941,7 @@ router.post('/', authLogin, async (req, res) => {
         ...(raw.metadata || {}),
         createdBy: currentUserDid,
       };
-    } else if (!['owner', 'admin'].includes(req.user?.role as string)) {
+    } else if (!isAdmin) {
       return res.status(403).json({ error: 'Not authorized to perform this action' });
     }
 
@@ -811,7 +954,30 @@ router.post('/', authLogin, async (req, res) => {
       }
     }
 
+    // Process discounts before creating checkout session
+    let processedDiscounts: any[] = [];
+    if (req.body.discounts && Array.isArray(req.body.discounts)) {
+      if (!isAdmin) {
+        return res.status(403).json({ error: 'Not allowed to apply discounts' });
+      }
+      try {
+        processedDiscounts = await processCheckoutSessionDiscounts(raw as any, req.body.discounts);
+      } catch (discountError) {
+        logger.error('Discount processing failed during checkout session creation', {
+          error: discountError.message,
+          discounts: req.body.discounts,
+        });
+        return res.status(400).json({ error: discountError.message });
+      }
+    }
+
+    // Include processed discounts in the checkout session data
+    if (processedDiscounts.length > 0) {
+      raw.discounts = processedDiscounts;
+    }
+
     const doc = await CheckoutSession.create(raw as any);
+
     let url = getUrl(`/checkout/${doc.submit_type}/${doc.id}`);
     if (createMine && currentUserDid) {
       url = withQuery(url, getConnectQueryParam({ userDid: currentUserDid }));
@@ -1063,11 +1229,24 @@ router.get('/retrieve/:id', user, async (req, res) => {
   // @ts-ignore
   doc.line_items = await Price.expand(doc.line_items, { upsell: true });
 
+  // Enhance line items with coupon information if discounts are applied
+  if (doc.discounts?.length) {
+    doc.line_items = await expandLineItemsWithCouponInfo(
+      doc.line_items as TLineItemExpanded[],
+      doc.discounts,
+      doc.currency_id
+    );
+  }
+
+  // Expand discounts with complete details
+  const enhancedDiscounts = await expandDiscountsWithDetails(doc.discounts);
+
   // check payment intent
   const paymentIntent = doc.payment_intent_id ? await PaymentIntent.findByPk(doc.payment_intent_id) : null;
   res.json({
     checkoutSession: {
       ...doc.toJSON(),
+      discounts: enhancedDiscounts,
       subscriptions,
     },
     paymentMethods: await getPaymentMethods(doc),
@@ -1116,32 +1295,6 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     );
     await checkoutSession.update({ currency_id: paymentCurrency.id });
 
-    // calculate amount and update checkout session
-    const { lineItems, trialInDays, trialEnd, now } = await calculateAndUpdateAmount(
-      checkoutSession,
-      paymentCurrency.id,
-      true
-    );
-
-    // Validate payment amounts meet minimum requirements
-    if (paymentMethod.type === 'stripe') {
-      const result = validatePaymentAmounts(lineItems, paymentCurrency, checkoutSession);
-      if (!result.valid) {
-        return res.status(400).json({ error: result.error });
-      }
-    }
-
-    // Validate checkout session ownership if it was created for a specific customer
-    if (checkoutSession.customer_did && checkoutSession.metadata?.createdBy) {
-      const createdByDid = checkoutSession.metadata.createdBy;
-      if (createdByDid !== req.user.did) {
-        return res.status(403).json({
-          error:
-            "It's not allowed to submit checkout sessions created by other users, please create your own checkout session",
-        });
-      }
-    }
-
     let customer = await Customer.findOne({ where: { did: req.user.did } });
     if (!customer) {
       const { user: userInfo } = await blocklet.getUser(req.user.did);
@@ -1248,6 +1401,39 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
 
     await checkoutSession.update({ customer_id: customer.id, customer_did: req.user.did });
 
+    // Verify and recalculate amount with current discounts
+    const { lineItems, trialInDays, trialEnd, now } = await calculateAndUpdateAmount(
+      checkoutSession,
+      paymentCurrency.id,
+      true
+    );
+
+    // Validate payment amounts meet minimum requirements
+    if (paymentMethod.type === 'stripe') {
+      const result = await validatePaymentAmounts(lineItems, paymentCurrency, checkoutSession);
+      if (!result.valid) {
+        return res.status(400).json({ error: result.error });
+      }
+    }
+
+    // Validate checkout session ownership if it was created for a specific customer
+    if (checkoutSession.customer_did && checkoutSession.metadata?.createdBy) {
+      const createdByDid = checkoutSession.metadata.createdBy;
+      if (createdByDid !== req.user.did) {
+        return res.status(403).json({
+          error:
+            "It's not allowed to submit checkout sessions created by other users, please create your own checkout session",
+        });
+      }
+    }
+
+    // Validate promotion codes are still valid during submission
+    await validatePromotionCodesOnSubmit(checkoutSession, {
+      lineItems,
+      customerId: req.user.did,
+      amount: checkoutSession.amount_subtotal,
+    });
+
     // create or update payment intent
     let paymentIntent: PaymentIntent | null = null;
     if (checkoutSession.mode === 'payment') {
@@ -1260,6 +1446,30 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         customer.email
       );
       paymentIntent = result.paymentIntent;
+
+      // Create discount records for payment mode immediately after payment intent creation
+      if (checkoutSession.discounts?.length) {
+        try {
+          const discountResult = await createDiscountRecordsForCheckout({
+            checkoutSession,
+            customerId: customer.id,
+            subscriptionIds: [], // No subscriptions for payment mode
+          });
+
+          logger.info('Created discount records for checkout session payment', {
+            checkoutSessionId: checkoutSession.id,
+            paymentIntentId: paymentIntent?.id,
+            discountRecordCount: discountResult.discountRecords.length,
+            newRecords: discountResult.subscriptionsUpdated.length,
+          });
+        } catch (discountError) {
+          logger.error('Failed to create discount records for checkout session payment', {
+            checkoutSessionId: checkoutSession.id,
+            paymentIntentId: paymentIntent?.id,
+            error: discountError.message,
+          });
+        }
+      }
     }
 
     // SetupIntent processing
@@ -1350,14 +1560,77 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         primarySubscription: subscription ? (subscription as any).id : null,
         enableSubscriptionGrouping: checkoutSession.enable_subscription_grouping,
       });
+
+      // Create discount records immediately after subscriptions are created
+      if (checkoutSession.discounts?.length) {
+        try {
+          const discountResult = await createDiscountRecordsForCheckout({
+            checkoutSession,
+            customerId: customer.id,
+            subscriptionIds: subscriptions.map((s) => s.id),
+          });
+
+          // Update subscription discount_id references
+          if (discountResult.subscriptionsUpdated.length > 0) {
+            try {
+              const subscriptionUpdateResult = await updateSubscriptionDiscountReferences({
+                discountRecords: discountResult.discountRecords,
+                subscriptionsUpdated: discountResult.subscriptionsUpdated,
+              });
+
+              logger.debug('Updated subscription discount_id references', {
+                updatedCount: subscriptionUpdateResult.updatedSubscriptions.length,
+                updatedSubscriptions: subscriptionUpdateResult.updatedSubscriptions,
+              });
+            } catch (subscriptionUpdateError) {
+              logger.error('Failed to update subscription discount_id references', {
+                checkoutSessionId: checkoutSession.id,
+                subscriptionsUpdated: discountResult.subscriptionsUpdated,
+                error: subscriptionUpdateError.message,
+              });
+              throw subscriptionUpdateError;
+            }
+          }
+
+          logger.info('Created discount records for checkout session subscriptions', {
+            checkoutSessionId: checkoutSession.id,
+            discountRecordCount: discountResult.discountRecords.length,
+            subscriptionIds: subscriptions.map((s) => s.id),
+            subscriptionsUpdated: discountResult.subscriptionsUpdated,
+          });
+        } catch (discountError) {
+          logger.error('Failed to create discount records for checkout session', {
+            checkoutSessionId: checkoutSession.id,
+            error: discountError.message,
+          });
+          return res
+            .status(400)
+            .json({ error: 'Failed to create discount records for checkout session, please try again later' });
+        }
+      }
     }
 
-    const fastCheckoutAmount = getFastCheckoutAmount(
-      lineItems,
-      checkoutSession.mode,
-      paymentCurrency.id,
-      trialInDays > 0 || trialEnd > now
-    );
+    // Prepare discount configuration
+    let discountConfig;
+    if (checkoutSession.discounts && checkoutSession.discounts.length > 0) {
+      const firstDiscount = checkoutSession.discounts[0];
+      if (firstDiscount?.coupon && checkoutSession.customer_id) {
+        discountConfig = {
+          promotionCodeId: firstDiscount.promotion_code,
+          couponId: firstDiscount.coupon,
+          customerId: checkoutSession.customer_id,
+        };
+      }
+    }
+
+    const fastCheckoutAmount = await getFastCheckoutAmount({
+      items: lineItems,
+      mode: checkoutSession.mode,
+      currencyId: paymentCurrency.id,
+      trialing: trialInDays > 0 || trialEnd > now,
+      minimumCycle: 1,
+      discountConfig,
+    });
     const paymentSettings = {
       payment_method_types: checkoutSession.payment_method_types,
       payment_method_options: {
@@ -1734,12 +2007,20 @@ router.post('/:id/fast-checkout-confirm', user, ensureCheckoutSessionOpen, async
       paymentIntent = result.paymentIntent;
     }
 
-    const fastCheckoutAmount = getFastCheckoutAmount(
-      lineItems,
-      checkoutSession.mode,
-      paymentCurrency.id,
-      trialInDays > 0 || trialEnd > now
-    );
+    const discountConfig = {
+      promotionCodeId: checkoutSession.discounts?.[0]?.promotion_code,
+      couponId: checkoutSession.discounts?.[0]?.coupon,
+      customerId: checkoutSession.customer_id,
+    };
+
+    const fastCheckoutAmount = await getFastCheckoutAmount({
+      items: lineItems,
+      mode: checkoutSession.mode,
+      currencyId: paymentCurrency.id,
+      trialing: trialInDays > 0 || trialEnd > now,
+      minimumCycle: 1,
+      discountConfig,
+    });
 
     const paymentSettings = {
       payment_method_types: checkoutSession.payment_method_types,
@@ -1800,10 +2081,11 @@ router.post('/:id/fast-checkout-confirm', user, ensureCheckoutSessionOpen, async
             ...paymentSettings,
           });
         }
-        checkoutSession.update({
+        await checkoutSession.update({
           status: 'complete',
           payment_status: 'paid',
         });
+
         await pAll(
           subscriptions.map((sub) => async () => {
             await sub.update({
@@ -2133,6 +2415,415 @@ router.delete('/:id/cross-sell', user, ensureCheckoutSessionOpen, async (req, re
   }
 });
 
+// Apply promotion code discount (preview only - doesn't create actual discount record)
+router.post('/:id/apply-promotion', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+    const { promotion_code: promotionCode, currency_id: currencyId } = req.body;
+
+    if (!promotionCode) {
+      return res.status(400).json({ error: 'Promotion code is required' });
+    }
+
+    if (!req.user) {
+      return res.status(403).json({ error: 'Authentication required' });
+    }
+
+    // Find customer by DID
+    const customer = await Customer.findOne({ where: { did: req.user.did } });
+    if (!customer) {
+      return res.status(400).json({ error: 'Customer not found' });
+    }
+
+    // Get currency
+    const curCurrencyId = currencyId || checkoutSession.currency_id;
+    if (!curCurrencyId) {
+      return res.status(400).json({ error: 'Currency not found in checkout session' });
+    }
+
+    const currency = await PaymentCurrency.findByPk(curCurrencyId);
+    if (!currency) {
+      return res.status(400).json({ error: 'Currency not found' });
+    }
+
+    const foundPromotionCode = (await PromotionCode.findOne({
+      where: { code: promotionCode },
+      include: [
+        {
+          model: Coupon,
+          as: 'coupon',
+          attributes: ['id', 'name', 'duration', 'duration_in_months'],
+        },
+      ],
+    })) as PromotionCode & { coupon: Coupon };
+
+    if (!foundPromotionCode || !foundPromotionCode.active) {
+      return res.status(400).json({ error: 'Promotion code not found or inactive' });
+    }
+
+    // Validate subscription grouping + repeating coupon combination
+    if (checkoutSession.enable_subscription_grouping) {
+      if (foundPromotionCode?.coupon?.duration === 'repeating') {
+        return res.status(400).json({
+          error:
+            'Repeating coupons cannot be used with subscription grouping. This limitation ensures proper discount management across multiple subscriptions in a single purchase.',
+        });
+      }
+    }
+
+    const checkoutItems = checkoutSession.line_items || [];
+    // Get line items
+    const expandedItems = await Price.expand(checkoutSession.line_items || [], { product: true, upsell: true });
+
+    // Calculate trial status for discount application (same logic as in calculateAndUpdateAmount)
+    const now = dayjs().unix();
+    const trialSetup = getSubscriptionTrialSetup(checkoutSession.subscription_data as any, currency.id);
+    const isTrialing = trialSetup.trialInDays > 0 || trialSetup.trialEnd > now;
+
+    // Apply discount using our new function
+    const discountResult = await applyDiscountsToLineItems({
+      lineItems: expandedItems,
+      promotionCodeId: foundPromotionCode.id,
+      couponId: foundPromotionCode.coupon_id,
+      customerId: customer.id,
+      currency,
+      billingContext: {
+        trialing: isTrialing,
+      },
+    });
+
+    if (!discountResult.discountSummary.appliedCoupon) {
+      return res
+        .status(400)
+        .json({ error: discountResult.notValidReason || 'Promotion code cannot be applied to this order' });
+    }
+
+    // Create discount configuration for checkout session
+    const coupon = await Coupon.findByPk(foundPromotionCode.coupon_id);
+    const discountConfig = {
+      promotion_code: foundPromotionCode.id,
+      coupon: coupon?.id,
+      discount_amount: discountResult.discountSummary.totalDiscountAmount,
+      verification_method: 'code',
+      verification_data: { code: promotionCode },
+    };
+
+    // Update checkout session with discount preview (without detailed coupon info in line_items)
+    await checkoutSession.update({
+      discounts: [discountConfig],
+      currency_id: curCurrencyId,
+      line_items: discountResult.enhancedLineItems.map((item: TLineItemExpanded) => {
+        const cur = checkoutItems.find((x) => x.price_id === item.price_id) as LineItem;
+        return {
+          ...cur,
+          discountable: item.discountable,
+          discount_amounts: item.discount_amounts,
+        };
+      }),
+      amount_subtotal: checkoutSession.amount_total, // Original amount
+      amount_total: discountResult.discountSummary.finalTotal, // Discounted amount
+      total_details: {
+        ...checkoutSession.total_details,
+        amount_discount: discountResult.discountSummary.totalDiscountAmount,
+      },
+      metadata: {
+        ...checkoutSession.metadata,
+        promotion_code: promotionCode,
+      },
+    });
+
+    // Create enhanced line items with complete coupon information for response
+    const enhancedLineItemsWithCoupon = await expandLineItemsWithCouponInfo(
+      discountResult.enhancedLineItems,
+      [discountConfig],
+      currency.id
+    );
+
+    logger.info('Promotion code applied to checkout session', {
+      sessionId: checkoutSession.id,
+      promotionCode,
+      originalAmount: checkoutSession.amount_subtotal,
+      discountAmount: discountResult.discountSummary.totalDiscountAmount,
+      finalAmount: discountResult.discountSummary.finalTotal,
+    });
+
+    // Expand discounts with complete details for response
+    const enhancedDiscounts = await expandDiscountsWithDetails([discountConfig]);
+
+    res.json({
+      ...checkoutSession.toJSON(),
+      line_items: enhancedLineItemsWithCoupon,
+      discounts: enhancedDiscounts,
+      discount_applied: true,
+    });
+  } catch (err) {
+    logger.error('Error applying promotion code', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// Recalculate promotion code discount when currency changes
+router.post('/:id/recalculate-promotion', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+    const { currency_id: newCurrencyId } = req.body;
+
+    if (!newCurrencyId) {
+      return res.status(400).json({ error: 'Currency ID is required' });
+    }
+
+    if (!req.user) {
+      return res.status(403).json({ error: 'Authentication required' });
+    }
+
+    // Check if there are existing discounts to recalculate
+    if (!checkoutSession.discounts?.length) {
+      return res.json({
+        ...checkoutSession.toJSON(),
+        discounts: [],
+        discount_applied: false,
+        message: 'No promotion codes to recalculate',
+      });
+    }
+
+    // Find customer by DID
+    const customer = await Customer.findOne({ where: { did: req.user.did } });
+    if (!customer) {
+      return res.status(400).json({ error: 'Customer not found' });
+    }
+
+    // Get new currency
+    const currency = await PaymentCurrency.findByPk(newCurrencyId);
+    if (!currency) {
+      return res.status(400).json({ error: 'Currency not found' });
+    }
+
+    const checkoutItems = checkoutSession.line_items || [];
+    // Get line items
+    const expandedItems = await Price.expand(checkoutSession.line_items || [], { product: true, upsell: true });
+
+    // Get the first discount (assuming only one promotion code at a time)
+    const existingDiscount = checkoutSession.discounts[0];
+    if (!existingDiscount) {
+      return res.status(400).json({ error: 'No discount found' });
+    }
+
+    const promotionCodeId = existingDiscount.promotion_code;
+    const couponId = existingDiscount.coupon;
+
+    if (!promotionCodeId || !couponId) {
+      return res.status(400).json({ error: 'Invalid discount configuration' });
+    }
+
+    // Validate promotion code and coupon still exist and are active
+    const [foundPromotionCode, coupon] = await Promise.all([
+      PromotionCode.findByPk(promotionCodeId),
+      Coupon.findByPk(couponId),
+    ]);
+
+    if (!foundPromotionCode || !foundPromotionCode.active) {
+      return res.status(400).json({ error: 'Promotion code no longer active' });
+    }
+
+    if (!coupon || !coupon.valid) {
+      return res.status(400).json({ error: 'Coupon no longer valid' });
+    }
+
+    // Apply discount with new currency
+    const discountResult = await applyDiscountsToLineItems({
+      lineItems: expandedItems,
+      promotionCodeId,
+      couponId,
+      customerId: customer.id,
+      currency,
+    });
+
+    // Check if discount can still be applied with the new currency
+    if (!discountResult.discountSummary.appliedCoupon) {
+      // Calculate original total without discount (finalTotal when no discount is applied)
+      const originalTotal = discountResult.discountSummary.finalTotal;
+
+      // Remove discount if it can't be applied with new currency
+      await checkoutSession.update({
+        discounts: [],
+        line_items: expandedItems.map((item) => {
+          const cur = checkoutItems.find((x) => x.price_id === item.price_id) as LineItem;
+          return {
+            ...cur,
+          };
+        }),
+        currency_id: newCurrencyId,
+        amount_subtotal: originalTotal,
+        amount_total: originalTotal,
+        total_details: {
+          ...checkoutSession.total_details,
+          amount_discount: '0',
+        },
+        metadata: {
+          ...omit(checkoutSession.metadata, ['promotion_code']),
+        },
+      });
+
+      logger.info('Promotion code removed due to currency incompatibility', {
+        sessionId: checkoutSession.id,
+        oldCurrencyId: checkoutSession.currency_id,
+        newCurrencyId,
+        promotionCode: foundPromotionCode.code,
+      });
+
+      return res.json({
+        ...checkoutSession.toJSON(),
+        line_items: expandedItems,
+        discounts: [],
+        discount_applied: false,
+        discount_removed_reason: 'currency_incompatible',
+      });
+    }
+
+    // Create updated discount configuration
+    const discountConfig = {
+      promotion_code: promotionCodeId,
+      coupon: couponId,
+      discount_amount: discountResult.discountSummary.totalDiscountAmount,
+      verification_method: existingDiscount.verification_method,
+      verification_data: existingDiscount.verification_data,
+    };
+
+    // Update checkout session with recalculated discount
+    await checkoutSession.update({
+      discounts: [discountConfig],
+      line_items: discountResult.enhancedLineItems.map((item: TLineItemExpanded) => {
+        const cur = checkoutItems.find((x) => x.price_id === item.price_id) as LineItem;
+        return {
+          ...cur,
+          discountable: item.discountable,
+          discount_amounts: item.discount_amounts,
+        };
+      }),
+      currency_id: newCurrencyId,
+      amount_subtotal: checkoutSession.amount_total, // Original amount
+      amount_total: discountResult.discountSummary.finalTotal, // Discounted amount
+      total_details: {
+        ...checkoutSession.total_details,
+        amount_discount: discountResult.discountSummary.totalDiscountAmount,
+      },
+    });
+
+    // Create enhanced line items with complete coupon information for response
+    const enhancedLineItemsWithCoupon = await expandLineItemsWithCouponInfo(
+      discountResult.enhancedLineItems,
+      [discountConfig],
+      currency.id
+    );
+
+    logger.info('Promotion code recalculated for new currency', {
+      sessionId: checkoutSession.id,
+      oldCurrencyId: checkoutSession.currency_id,
+      newCurrencyId,
+      promotionCode: foundPromotionCode.code,
+      oldDiscountAmount: existingDiscount?.discount_amount || '0',
+      newDiscountAmount: discountResult.discountSummary.totalDiscountAmount,
+    });
+
+    // Expand discounts with complete details for response
+    const enhancedDiscounts = await expandDiscountsWithDetails([discountConfig]);
+
+    res.json({
+      ...checkoutSession.toJSON(),
+      line_items: enhancedLineItemsWithCoupon,
+      discounts: enhancedDiscounts,
+      discount_applied: true,
+      discount_recalculated: true,
+    });
+  } catch (err) {
+    logger.error('Error recalculating promotion code', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// Remove promotion code discount (remove preview)
+router.delete('/:id/remove-promotion', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+
+    if (checkoutSession.status !== 'open') {
+      return res.status(400).json({ error: 'Checkout session is not open' });
+    }
+
+    // Get currency
+    const currency = await PaymentCurrency.findByPk(checkoutSession.currency_id);
+    if (!currency) {
+      return res.status(400).json({ error: 'Currency not found' });
+    }
+
+    // Get original line items without discount information
+    const originalItems = await Price.expand(checkoutSession.line_items || [], { product: true, upsell: true });
+
+    // Calculate trial status for accurate original amount calculation
+    const now = dayjs().unix();
+    const trialSetup = getSubscriptionTrialSetup(checkoutSession.subscription_data as any, currency.id);
+    const isTrialing = trialSetup.trialInDays > 0 || trialSetup.trialEnd > now;
+
+    // Calculate original amounts without any discounts
+    const originalResult = await applyDiscountsToLineItems({
+      lineItems: originalItems,
+      couponId: 'dummy', // Won't be found, so no discount applied
+      customerId: 'dummy',
+      currency,
+      billingContext: {
+        trialing: isTrialing,
+      },
+    });
+
+    // Update checkout session to remove discount
+    await checkoutSession.update({
+      discounts: [],
+      line_items: originalResult.enhancedLineItems.map((item: TLineItemExpanded) => ({
+        price_id: item.price_id,
+        quantity: item.quantity,
+        custom_amount: item.custom_amount,
+        upsell_price_id: item.upsell_price_id,
+        cross_sell: item.cross_sell,
+        adjustable_quantity: item.adjustable_quantity,
+      })),
+      amount_subtotal: originalResult.discountSummary.finalTotal,
+      amount_total: originalResult.discountSummary.finalTotal,
+      total_details: {
+        ...checkoutSession.total_details,
+        amount_discount: '0',
+      },
+      metadata: {
+        ...omit(checkoutSession.metadata, ['promotion_code']),
+      },
+    });
+
+    logger.info('Promotion code removed from checkout session', {
+      sessionId: checkoutSession.id,
+    });
+
+    res.json({
+      ...checkoutSession.toJSON(),
+      line_items: originalResult.enhancedLineItems,
+      discount_applied: false,
+    });
+  } catch (err) {
+    logger.error('Error removing promotion code', {
+      sessionId: req.params.id,
+      error: err.message,
+      stack: err.stack,
+    });
+    res.status(500).json({ error: err.message });
+  }
+});
+
 // change payment amount
 router.put('/:id/amount', ensureCheckoutSessionOpen, async (req, res) => {
   try {