payment-kit 1.20.10 → 1.20.12

package/api/src/libs/invoice.ts

@@ -24,9 +24,10 @@ import {
   TLineItemExpanded,
   UsageRecord,
   Lock,
+  DiscountAmount,
 } from '../store/models';
 import { getConnectQueryParam } from './util';
-import { expandLineItems, getPriceUintAmountByCurrency } from './session';
+import { expandLineItems } from './session';
 import dayjs from './dayjs';
 import {
   getSubscriptionCycleAmount,
@@ -39,6 +40,7 @@ import logger from './logger';
 import { ensureOverdraftProtectionPrice } from './overdraft-protection';
 import { CHARGE_SUPPORTED_CHAIN_TYPES } from './constants';
 import { emitAsync } from './event';
+import { getPriceUintAmountByCurrency } from './price';
 
 export function getCustomerInvoicePageUrl({
   invoiceId,
@@ -67,7 +69,7 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
       include: [{ model: InvoiceItem, as: 'lines' }],
     });
     if (!doc) {
-      throw new Error(`Invoice not found in ${invoiceId}`);
+      throw new Error(`Invoice not found: ${invoiceId}`);
     }
     const json = doc.toJSON();
     const products = (await Product.findAll()).map((x) => x.toJSON());
@@ -159,8 +161,25 @@ export async function getInvoiceShouldPayTotal(invoice: Invoice) {
         return item;
       })
     );
-    const amount = getSubscriptionCycleAmount(expandedItems, subscription.currency_id);
-    return amount?.total || invoice.total;
+
+    const baseAmount = getSubscriptionCycleAmount(expandedItems, subscription.currency_id);
+    let shouldPayTotal = baseAmount?.total || invoice.total;
+
+    // Apply discount if exists
+    if (baseAmount?.total && invoice.total_discount_amounts && invoice.total_discount_amounts.length > 0) {
+      const totalDiscountAmount = invoice.total_discount_amounts.reduce((sum, discount) => {
+        return new BN(sum).add(new BN(discount.amount.toString())).toString();
+      }, '0');
+
+      shouldPayTotal = new BN(shouldPayTotal).sub(new BN(totalDiscountAmount)).toString();
+
+      // Ensure the final amount doesn't go below zero
+      if (new BN(shouldPayTotal).lt(new BN('0'))) {
+        shouldPayTotal = '0';
+      }
+    }
+
+    return shouldPayTotal;
   } catch (err) {
     console.error(`Error in getInvoiceShouldPayTotal for invoice ${invoice.id}:`, err);
     return invoice.total;
@@ -375,6 +394,7 @@ type BaseInvoiceProps = {
   description: string;
   statement_descriptor?: string;
   total: string;
+  subtotal?: string;
   amount_due?: string;
   amount_paid?: string;
   amount_remaining?: string;
@@ -382,6 +402,9 @@ type BaseInvoiceProps = {
   payment_intent_id?: string;
   checkout_session_id?: string;
   metadata?: Record<string, any>;
+  // Discount fields
+  discounts?: string[];
+  total_discount_amounts?: DiscountAmount[];
   items?: Array<{
     price_id: string;
     amount: string;
@@ -393,6 +416,9 @@ type BaseInvoiceProps = {
     };
     metadata?: Record<string, any>;
     subscription_item_id?: string;
+    // Discount fields for InvoiceItem
+    discountable?: boolean;
+    discount_amounts?: DiscountAmount[];
   }>;
   auto_advance?: boolean;
   paid?: boolean;
@@ -449,8 +475,8 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
     attempt_count: 0,
     attempted: false,
     tax: '0',
-    discounts: [],
-    total_discount_amounts: [],
+    discounts: props.discounts || [],
+    total_discount_amounts: props.total_discount_amounts || [],
     collection_method: 'charge_automatically',
     ...extraProps,
     livemode,
@@ -471,7 +497,7 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
     subscription_id: subscription?.id,
     checkout_session_id: checkoutSessionId,
     total,
-    subtotal: total,
+    subtotal: props.subtotal || total,
     amount_due: amountDue,
     amount_paid: amountPaid,
     amount_remaining: amountRemaining,
@@ -507,9 +533,11 @@ async function createInvoiceWithItems(props: BaseInvoiceProps): Promise<{
         invoice_id: invoice.id,
         subscription_id: subscription?.id,
         subscription_item_id: item.subscription_item_id,
-        discountable: false,
-        discounts: [],
-        discount_amounts: [],
+        discountable: item.discountable || false,
+        discounts: [], // Keep as empty for now - this is legacy field
+        discount_amounts:
+          item.discount_amounts?.map((d) => ({ amount: new BN(d.amount || '0').toString(), discount: d.discount })) ||
+          [],
         proration: false,
         proration_details: {},
         metadata: item.metadata || {},
@@ -609,6 +637,9 @@ export async function ensureInvoiceAndItems({
       period: setup.period,
       metadata: x.metadata || {},
       subscription_item_id: subscriptionItems.find((si) => si.price_id === price.id)?.id,
+      // Discount fields from pre-calculated line items
+      discountable: x.discountable || false,
+      discount_amounts: x.discount_amounts || [],
     };
   });
 
@@ -632,16 +663,19 @@ export async function ensureInvoiceAndItems({
     auto_advance: props.auto_advance,
 
     total: props.total,
+    subtotal: props.subtotal || props.total,
     amount_remaining: props.amount_remaining || remaining,
     amount_paid: props.amount_paid,
     amount_due: props.amount_due || remaining,
-    subtotal_excluding_tax: props.total || '0',
+    subtotal_excluding_tax: props.subtotal || props.total || '0',
     starting_token_balance: result.starting,
     ending_token_balance: result.ending,
 
     footer: props.footer,
     custom_fields: props.custom_fields,
     payment_settings: props.payment_settings || subscription?.payment_settings,
+    discounts: props.discounts,
+    total_discount_amounts: props.total_discount_amounts || [],
     metadata: {
       ...props.metadata,
       starting_token_balance: result.starting,
@@ -733,19 +767,19 @@ export async function ensureOverdraftProtectionInvoiceAndItems({
   const invoicePrice = price?.currency_options?.find((x: any) => x.currency_id === paymentIntent?.currency_id);
 
   if (!subscription.overdraft_protection?.enabled) {
-    throw new Error('create overdraft protection invoice skipped due to overdraft protection not enabled');
+    throw new Error('Overdraft protection invoice creation skipped: overdraft protection is not enabled');
   }
 
   if (!invoicePrice) {
-    throw new Error('overdraft protection invoice price not found');
+    throw new Error('Overdraft protection invoice price not found');
   }
   const currency = await PaymentCurrency.findByPk(invoicePrice.currency_id);
   if (!currency) {
-    throw new Error('overdraft protection invoice currency not found');
+    throw new Error('Overdraft protection invoice currency not found');
   }
   const paymentMethod = await PaymentMethod.findByPk(currency?.payment_method_id);
   if (!paymentMethod) {
-    throw new Error('overdraft protection invoice payment method not found');
+    throw new Error('Overdraft protection invoice payment method not found');
   }
 
   if (paymentMethod.type !== 'arcblock') {
@@ -754,7 +788,7 @@ export async function ensureOverdraftProtectionInvoiceAndItems({
 
   const { unused } = await isSubscriptionOverdraftProtectionEnabled(subscription, paymentIntent?.currency_id);
   if (new BN(unused).lt(new BN(invoicePrice.unit_amount))) {
-    throw new Error('create overdraft protection invoice skipped due to insufficient overdraft protection');
+    throw new Error('Overdraft protection invoice creation skipped: insufficient overdraft protection funds');
   }
 
   const result = await createInvoiceWithItems({

package/api/src/libs/math-utils.ts

@@ -0,0 +1,6 @@
+export function trimDecimals(value: string | number, maxDecimals: number): string {
+  const num = typeof value === 'number' ? value : parseFloat(value || '0');
+  const multiplier = 10 ** maxDecimals;
+  const rounded = Math.round(num * multiplier) / multiplier;
+  return rounded.toString();
+}

package/api/src/libs/price.ts

@@ -0,0 +1,43 @@
+import type { Price, TPriceExpanded } from '../store/models';
+import type { PriceCurrency } from '../store/models/types';
+
+/**
+ * Get price currency options for a given price
+ */
+export function getPriceCurrencyOptions(price: Price | TPriceExpanded): PriceCurrency[] {
+  if (Array.isArray(price.currency_options)) {
+    return price.currency_options;
+  }
+
+  return [
+    {
+      currency_id: price.currency_id,
+      unit_amount: price.unit_amount,
+      custom_unit_amount: price.custom_unit_amount || null,
+      tiers: null,
+    },
+  ];
+}
+
+/**
+ * Get price unit amount by currency ID
+ */
+export function getPriceUintAmountByCurrency(price: Price | TPriceExpanded, currencyId: string) {
+  const options = getPriceCurrencyOptions(price);
+  const option = options.find((x) => x.currency_id === currencyId);
+  if (option) {
+    if (option.custom_unit_amount) {
+      return option.custom_unit_amount.preset || option.custom_unit_amount.presets[0];
+    }
+    return option.unit_amount;
+  }
+
+  if (price.currency_id === currencyId) {
+    if (price.custom_unit_amount) {
+      return price.custom_unit_amount.preset || price.custom_unit_amount.presets[0];
+    }
+    return price.unit_amount;
+  }
+
+  throw new Error(`Currency option ${currencyId} not configured for price ${price.id}`);
+}

package/api/src/libs/session.ts

@@ -6,8 +6,11 @@ import isEqual from 'lodash/isEqual';
 import pAll from 'p-all';
 import { omit } from 'lodash';
 import dayjs from './dayjs';
+import { validCoupon } from './discount/coupon';
+import { getPriceUintAmountByCurrency, getPriceCurrencyOptions } from './price';
 
 import {
+  Coupon,
   Customer,
   Invoice,
   PaymentCurrency,
@@ -21,16 +24,12 @@ import {
   type TPaymentCurrency,
   type TPaymentMethodExpanded,
 } from '../store/models';
-import type { Price, Price as TPrice } from '../store/models/price';
+import { Price, Price as TPrice } from '../store/models/price';
 import type { Product } from '../store/models/product';
-import type {
-  PaymentBeneficiary,
-  PriceCurrency,
-  PriceRecurring,
-  SubscriptionBillingThresholds,
-} from '../store/models/types';
+import type { PaymentBeneficiary, PriceRecurring, SubscriptionBillingThresholds } from '../store/models/types';
 import { wallet } from './auth';
 import logger from './logger';
+import { applyDiscountsToLineItems } from './discount/discount';
 
 export function getStatementDescriptor(items: any[]) {
   for (const item of items) {
@@ -59,50 +58,51 @@ export function getCheckoutMode(items: TLineItemExpanded[] = []) {
   return 'payment';
 }
 
-export function getPriceUintAmountByCurrency(price: TPrice | TPriceExpanded, currencyId: string) {
-  const options = getPriceCurrencyOptions(price);
-  const option = options.find((x) => x.currency_id === currencyId);
-  if (option) {
-    if (option.custom_unit_amount) {
-      return option.custom_unit_amount.preset || option.custom_unit_amount.presets[0];
-    }
-    return option.unit_amount;
-  }
-
-  if (price.currency_id === currencyId) {
-    if (price.custom_unit_amount) {
-      return price.custom_unit_amount.preset || price.custom_unit_amount.presets[0];
-    }
-    return price.unit_amount;
-  }
-
-  throw new Error(`Currency option ${currencyId} not configured for price ${price.id}`);
-}
-
-export function getPriceCurrencyOptions(price: TPrice | TPriceExpanded): PriceCurrency[] {
-  if (Array.isArray(price.currency_options)) {
-    return price.currency_options;
+// Calculate checkout amount with optional discount processing
+export async function getCheckoutAmount(
+  items: TLineItemExpanded[],
+  currencyId: string,
+  trialing = false,
+  discountConfig?: {
+    promotionCodeId?: string;
+    couponId?: string;
+    customerId?: string;
   }
-
-  return [
-    {
-      currency_id: price.currency_id,
-      unit_amount: price.unit_amount,
-      custom_unit_amount: price.custom_unit_amount || null,
-      tiers: null,
-    },
-  ];
-}
-
-// FIXME: apply coupon for discounts
-export function getCheckoutAmount(items: TLineItemExpanded[], currencyId: string, trialing = false) {
+) {
+  let processedItems = items;
   let renew = new BN(0);
 
   if (items.find((x) => (x.upsell_price || x.price).custom_unit_amount) && items.length > 1) {
     throw new Error('Multiple items with custom unit amount are not supported');
   }
 
-  const total = items
+  // Apply discounts if discount configuration is provided
+  if (discountConfig?.couponId && discountConfig?.customerId) {
+    try {
+      const currency = await PaymentCurrency.findByPk(currencyId);
+      if (currency) {
+        const discountResult = await applyDiscountsToLineItems({
+          lineItems: items,
+          promotionCodeId: discountConfig.promotionCodeId,
+          couponId: discountConfig.couponId,
+          customerId: discountConfig.customerId,
+          currency,
+          billingContext: {
+            trialing,
+          },
+        });
+
+        if (discountResult.discountSummary.appliedCoupon) {
+          processedItems = discountResult.enhancedLineItems;
+        }
+      }
+    } catch (error) {
+      // If discount processing fails, continue with original items
+      console.warn('Failed to apply discounts in getCheckoutAmount:', error.message);
+    }
+  }
+
+  const subtotal = processedItems
     .reduce((acc, x) => {
       if (x.custom_amount) {
         return acc.add(new BN(x.custom_amount));
@@ -131,7 +131,31 @@ export function getCheckoutAmount(items: TLineItemExpanded[], currencyId: string
     }, new BN(0))
     .toString();
 
-  return { subtotal: total, total, renew: renew.toString(), discount: '0', shipping: '0', tax: '0' };
+  // Calculate total discount amount from processed line items
+  let totalDiscountAmount = new BN(0);
+  processedItems.forEach((item) => {
+    if ((item as any).discount_amounts?.length > 0) {
+      (item as any).discount_amounts.forEach((discountAmount: any) => {
+        totalDiscountAmount = totalDiscountAmount.add(new BN(discountAmount.amount || '0'));
+      });
+    }
+  });
+
+  // Ensure discount doesn't exceed subtotal
+  const adjustedDiscount = totalDiscountAmount.gt(new BN(subtotal)) ? new BN(subtotal) : totalDiscountAmount;
+
+  const finalTotal = new BN(subtotal).sub(adjustedDiscount);
+  const adjustedTotal = finalTotal.lt(new BN('0')) ? '0' : finalTotal.toString();
+
+  return {
+    subtotal: subtotal || '0',
+    total: adjustedTotal,
+    renew: renew.toString() || '0',
+    discount: adjustedDiscount.toString(),
+    shipping: '0',
+    tax: '0',
+    processedItems, // Return processed items with discount information
+  };
 }
 
 export function getRecurringPeriod(recurring: PriceRecurring) {
@@ -294,19 +318,31 @@ export function canUpsell(from: TPrice, to: TPrice) {
   return true;
 }
 
-export function getFastCheckoutAmount(
-  items: TLineItemExpanded[],
-  mode: string,
-  currencyId: string,
+export async function getFastCheckoutAmount({
+  items,
+  mode,
+  currencyId,
   trialing = false,
-  minimumCycle = 1
-) {
-  if (minimumCycle < 1) {
+  minimumCycle = 1,
+  discountConfig,
+}: {
+  items: TLineItemExpanded[];
+  mode: string;
+  currencyId: string;
+  trialing?: boolean;
+  minimumCycle?: number;
+  discountConfig?: {
+    promotionCodeId?: string;
+    couponId?: string;
+    customerId?: string;
+  };
+}) {
+  if (!minimumCycle || minimumCycle < 1) {
     // eslint-disable-next-line no-param-reassign
     minimumCycle = 1;
   }
 
-  const { total, renew } = getCheckoutAmount(items, currencyId, trialing);
+  const { total, renew } = await getCheckoutAmount(items, currencyId, trialing, discountConfig);
 
   if (mode === 'payment' || mode === 'auto-recharge-auth') {
     return total;
@@ -1008,11 +1044,11 @@ export function validateStripePaymentAmounts(amount: string, currency: PaymentCu
  * @param mode Checkout mode
  * @returns Validation result with error message if any
  */
-export function validatePaymentAmounts(
+export async function validatePaymentAmounts(
   lineItems: TLineItemExpanded[],
   currency: PaymentCurrency,
   checkoutSession: CheckoutSession
-): { valid: boolean; error?: string } {
+): Promise<{ valid: boolean; error?: string }> {
   const enableGrouping = checkoutSession.enable_subscription_grouping;
   const oneTimeItems = getOneTimeLineItems(lineItems);
   const recurringItems = getRecurringLineItems(lineItems);
@@ -1021,7 +1057,7 @@ export function validatePaymentAmounts(
 
   // Case 1: All one-time items - validate total payment amount
   if (recurringItems.length === 0 && oneTimeItems.length > 0) {
-    const { total } = getCheckoutAmount(lineItems, currency.id);
+    const { total } = await getCheckoutAmount(lineItems, currency.id);
     if (new BN(total).lt(new BN(minAmountInUnits))) {
       return {
         valid: false,
@@ -1057,7 +1093,7 @@ export function validatePaymentAmounts(
       }
     } else {
       // When grouping is disabled, validate total subscription amount
-      const { renew } = getCheckoutAmount(lineItems, currency.id);
+      const { renew } = await getCheckoutAmount(lineItems, currency.id);
       if (new BN(renew).lt(new BN(minAmountInUnits))) {
         return {
           valid: false,
@@ -1069,3 +1105,152 @@ export function validatePaymentAmounts(
 
   return { valid: true };
 }
+
+/**
+ * Process discount application for checkout session data
+ * Validates coupon existence and basic validity, calculates discount amounts
+ * Customer-specific validations are done later during checkout submission
+ */
+export async function processCheckoutSessionDiscounts(
+  checkoutData: {
+    currency_id: string;
+    amount_total: string;
+    line_items?: any[];
+  },
+  discounts: Array<{ coupon: string }>
+): Promise<
+  Array<{
+    coupon: string;
+    verification_method: string;
+  }>
+> {
+  if (!discounts || !Array.isArray(discounts) || discounts.length === 0) {
+    return [];
+  }
+
+  // Get currency for discount calculations
+  const currency = await PaymentCurrency.findByPk(checkoutData.currency_id);
+  if (!currency) {
+    throw new Error('Currency not found');
+  }
+
+  const processedDiscounts: Array<{
+    coupon: string;
+    verification_method: string;
+  }> = [];
+
+  const expandedItems = await Price.expand(checkoutData.line_items || [], { product: true, upsell: true });
+
+  // Process discounts concurrently for better performance
+  const discountProcessingTasks = discounts.map((discountSpec, index) => async () => {
+    if (!discountSpec.coupon) {
+      throw new Error(`Coupon ID is required for discount at index ${index}`);
+    }
+
+    const coupon = await Coupon.findByPk(discountSpec.coupon);
+    if (!coupon) {
+      throw new Error(`Coupon '${discountSpec.coupon}' not found`);
+    }
+
+    // Validate coupon basic validity
+    const couponValidation = validCoupon(coupon, expandedItems as TLineItemExpanded[]);
+    if (!couponValidation.valid) {
+      throw new Error(`Coupon '${discountSpec.coupon}' is not valid: ${couponValidation.reason}`);
+    }
+    return {
+      coupon: coupon.id,
+      verification_method: 'direct',
+    };
+  });
+
+  const processedDiscountsArray = await pAll(discountProcessingTasks, { concurrency: 5 });
+  processedDiscounts.push(...processedDiscountsArray);
+
+  return processedDiscounts;
+}
+
+/**
+ * Recalculate checkout session amounts with applied discounts
+ */
+export async function getCheckoutSessionAmounts(checkoutSession: CheckoutSession) {
+  const { discounts } = checkoutSession;
+
+  // Ensure we always have safe default values
+  const safeSubtotal = checkoutSession.amount_subtotal || '0';
+  const safeTotal = checkoutSession.amount_total || '0';
+  const safeTotalDetails = checkoutSession.total_details || {
+    amount_discount: '0',
+    amount_shipping: '0',
+    amount_tax: '0',
+  };
+
+  // If no discounts, return current amounts with safe defaults
+  if (!discounts || discounts.length === 0) {
+    return {
+      amount_subtotal: safeSubtotal,
+      amount_total: safeTotal,
+      total_details: {
+        amount_discount: safeTotalDetails.amount_discount || '0',
+        amount_shipping: safeTotalDetails.amount_shipping || '0',
+        amount_tax: safeTotalDetails.amount_tax || '0',
+      },
+    };
+  }
+
+  const originalTotal = safeTotal;
+  let totalDiscountAmount = new BN('0');
+
+  // Calculate discount for each coupon
+  const discountPromises = discounts.map(async (discount) => {
+    if (!discount.coupon) {
+      return new BN('0');
+    }
+
+    const coupon = await Coupon.findByPk(discount.coupon);
+
+    if (!coupon || !coupon.valid) {
+      return new BN('0');
+    }
+
+    let discountAmount = new BN('0');
+    const baseAmount = new BN(originalTotal);
+
+    if (coupon.percent_off > 0) {
+      // Percentage discount
+      discountAmount = baseAmount.mul(new BN(coupon.percent_off)).div(new BN(100));
+    } else if (coupon.amount_off && new BN(coupon.amount_off).gt(new BN('0'))) {
+      // Fixed amount discount
+      discountAmount = new BN(coupon.amount_off);
+    }
+
+    // Ensure discount doesn't exceed original amount
+    if (discountAmount.gt(baseAmount)) {
+      discountAmount = baseAmount;
+    }
+
+    return discountAmount;
+  });
+
+  const discountAmounts = await Promise.all(discountPromises);
+  totalDiscountAmount = discountAmounts.reduce((sum: BN, amount: BN) => sum.add(amount), new BN('0'));
+
+  // Ensure total discount doesn't exceed original amount
+  if (totalDiscountAmount.gt(new BN(originalTotal))) {
+    totalDiscountAmount = new BN(originalTotal);
+  }
+
+  const finalTotal = new BN(originalTotal).sub(totalDiscountAmount);
+  // Ensure total doesn't go below 0
+  const adjustedTotal = finalTotal.lt(new BN('0')) ? '0' : finalTotal.toString();
+
+  return {
+    amount_subtotal: safeSubtotal,
+    amount_total: adjustedTotal,
+    total_details: {
+      amount_discount: totalDiscountAmount.toString(),
+      amount_shipping: safeTotalDetails.amount_shipping || '0',
+      amount_tax: safeTotalDetails.amount_tax || '0',
+    },
+    discounts,
+  };
+}

package/api/src/libs/subscription.ts

@@ -30,12 +30,8 @@ import { createEvent } from './audit';
 import dayjs from './dayjs';
 import env from './env';
 import logger from './logger';
-import {
-  getPriceCurrencyOptions,
-  getPriceUintAmountByCurrency,
-  getRecurringPeriod,
-  getSubscriptionCreateSetup,
-} from './session';
+import { getPriceCurrencyOptions, getPriceUintAmountByCurrency } from './price';
+import { getRecurringPeriod, getSubscriptionCreateSetup } from './session';
 import { getConnectQueryParam, getCustomerStakeAddress } from './util';
 import { wallet } from './auth';
 import { getGasPayerExtra } from './payment';