payment-kit 1.18.29 → 1.18.31

package/api/src/libs/session.ts

@@ -3,12 +3,34 @@ import type { TransactionInput } from '@ocap/client';
 import { BN } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import isEqual from 'lodash/isEqual';
-
-import type { CheckoutSession, TLineItemExpanded, TPaymentCurrency, TPaymentMethodExpanded } from '../store/models';
-import type { Price, TPrice } from '../store/models/price';
+import pAll from 'p-all';
+import { omit } from 'lodash';
+import dayjs from './dayjs';
+
+import {
+  Customer,
+  Invoice,
+  PaymentCurrency,
+  PaymentMethod,
+  SetupIntent,
+  Subscription,
+  SubscriptionItem,
+  TPriceExpanded,
+  type CheckoutSession,
+  type TLineItemExpanded,
+  type TPaymentCurrency,
+  type TPaymentMethodExpanded,
+} from '../store/models';
+import type { Price, Price as TPrice } from '../store/models/price';
 import type { Product } from '../store/models/product';
-import type { PaymentBeneficiary, PriceCurrency, PriceRecurring } from '../store/models/types';
+import type {
+  PaymentBeneficiary,
+  PriceCurrency,
+  PriceRecurring,
+  SubscriptionBillingThresholds,
+} from '../store/models/types';
 import { wallet } from './auth';
+import logger from './logger';
 
 export function getStatementDescriptor(items: any[]) {
   for (const item of items) {
@@ -37,7 +59,7 @@ export function getCheckoutMode(items: TLineItemExpanded[] = []) {
   return 'payment';
 }
 
-export function getPriceUintAmountByCurrency(price: TPrice, currencyId: string) {
+export function getPriceUintAmountByCurrency(price: TPrice | TPriceExpanded, currencyId: string) {
   const options = getPriceCurrencyOptions(price);
   const option = options.find((x) => x.currency_id === currencyId);
   if (option) {
@@ -57,7 +79,7 @@ export function getPriceUintAmountByCurrency(price: TPrice, currencyId: string)
   throw new Error(`Currency option ${currencyId} not configured for price ${price.id}`);
 }
 
-export function getPriceCurrencyOptions(price: TPrice): PriceCurrency[] {
+export function getPriceCurrencyOptions(price: TPrice | TPriceExpanded): PriceCurrency[] {
   if (Array.isArray(price.currency_options)) {
     return price.currency_options;
   }
@@ -170,12 +192,12 @@ export function getSupportedPaymentCurrencies(items: TLineItemExpanded[]) {
 export function isLineItemCurrencyAligned(list: TLineItemExpanded[], index: number) {
   const prices = list.map((x) => x.upsell_price || x.price);
 
-  const current = getPriceCurrencyOptions(prices[index] as TPrice)
+  const current = getPriceCurrencyOptions(prices[index] as any)
     .map((x) => x.currency_id)
     .sort();
 
   for (let i = 0; i < index; i++) {
-    const previous = getPriceCurrencyOptions(prices[i] as TPrice)
+    const previous = getPriceCurrencyOptions(prices[i] as any)
       .map((x) => x.currency_id)
       .sort();
     if (isEqual(current, previous) === false) {
@@ -383,3 +405,573 @@ export function isDonationCheckoutSession(checkoutSession: CheckoutSession): boo
     !!checkoutSession.metadata?.is_donation
   );
 }
+
+/**
+ * Format subscription product name based on line items
+ */
+export function formatSubscriptionProduct(items: TLineItemExpanded[], maxLength = 3) {
+  const names = items.map((x) => x.price?.product?.name || '').filter(Boolean);
+  return names.length > maxLength ? `${names.slice(0, maxLength).join(', ')} ...` : names.join(', ');
+}
+
+/**
+ * Setup subscription creation parameters
+ */
+export function getSubscriptionCreateSetup(
+  items: TLineItemExpanded[],
+  currencyId: string,
+  trialInDays = 0,
+  trialEnd = 0
+) {
+  let setup = new BN(0);
+
+  items.forEach((x) => {
+    const price = x.upsell_price || x.price;
+    const unit = getPriceUintAmountByCurrency(price, currencyId);
+    const amount = new BN(unit).mul(new BN(x.quantity));
+    if (price.type === 'recurring') {
+      if (price.recurring?.usage_type === 'licensed') {
+        setup = setup.add(amount);
+      }
+    }
+    if (price.type === 'one_time') {
+      setup = setup.add(amount);
+    }
+  });
+
+  const now = dayjs().unix();
+  const item = items.find((x) => (x.upsell_price || x.price).type === 'recurring');
+  const recurring = (item?.upsell_price || item?.price)?.recurring as PriceRecurring;
+  const cycle = getRecurringPeriod(recurring);
+
+  let trialStartAt = 0;
+  let trialEndAt = 0;
+  if (+trialEnd && trialEnd > now) {
+    trialStartAt = now;
+    trialEndAt = trialEnd;
+  } else if (trialInDays) {
+    trialStartAt = now;
+    trialEndAt = dayjs().add(trialInDays, 'day').unix();
+  }
+
+  const periodStart = trialStartAt || now;
+  const periodEnd = trialEndAt || dayjs().add(cycle, 'millisecond').unix();
+
+  return {
+    recurring,
+    cycle: {
+      duration: cycle,
+      anchor: periodEnd,
+    },
+    trial: {
+      start: trialStartAt,
+      end: trialEndAt,
+    },
+    period: {
+      start: periodStart,
+      end: periodEnd,
+    },
+    amount: {
+      setup: setup.toString(),
+    },
+  };
+}
+
+/**
+ * Creates subscription groupings based on checkout session configuration
+ * @param {Object} params - Parameters for subscription creation
+ * @returns {Object} Created subscription information
+ */
+export async function createGroupSubscriptions({
+  checkoutSession,
+  lineItems,
+  customer,
+  paymentSettings,
+  setupIntent,
+  trialConfig = {},
+}: {
+  checkoutSession: CheckoutSession;
+  lineItems: TLineItemExpanded[];
+  customer: Customer;
+  paymentSettings: { method: PaymentMethod; currency: PaymentCurrency };
+  setupIntent: SetupIntent | null;
+  trialConfig?: { trialInDays?: number; trialEnd?: number };
+}) {
+  const enableGrouping = checkoutSession.enable_subscription_grouping;
+
+  // Filter recurring items only
+  const recurringItems = getRecurringLineItems(lineItems);
+  if (recurringItems.length === 0) {
+    logger.info('No recurring items found for subscription', {
+      session: checkoutSession.id,
+    });
+    return { subscriptions: [], subscriptionGroups: {}, primarySubscription: null };
+  }
+
+  try {
+    // Process based on grouping mode
+    if (!enableGrouping) {
+      // Single subscription mode
+      const result = await createSingleSubscription({
+        checkoutSession,
+        lineItems: recurringItems,
+        customer,
+        paymentSettings,
+        setupIntent,
+        trialConfig,
+      });
+      return result;
+    }
+    // Multiple subscriptions mode
+    const result = await createMultipleSubscriptions({
+      checkoutSession,
+      lineItems,
+      customer,
+      paymentSettings,
+      setupIntent,
+      trialConfig,
+    });
+    return result;
+  } catch (error) {
+    logger.error('Failed to create subscriptions', {
+      error: error.message,
+      session: checkoutSession.id,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Creates a single subscription for all items
+ */
+async function createSingleSubscription(params: {
+  checkoutSession: CheckoutSession;
+  lineItems: TLineItemExpanded[];
+  customer: Customer;
+  paymentSettings: { method: PaymentMethod; currency: PaymentCurrency };
+  setupIntent: SetupIntent | null;
+  trialConfig?: { trialInDays?: number; trialEnd?: number };
+}) {
+  const { checkoutSession, lineItems, customer, paymentSettings, setupIntent, trialConfig } = params;
+  const existingSubscriptionId = checkoutSession.subscription_id;
+
+  const subscription = await createOrUpdateSubscription({
+    existingSubscriptionId,
+    checkoutSession,
+    lineItems,
+    customer,
+    paymentSettings,
+    setupIntent,
+    trialConfig,
+  });
+
+  logger.info('Single subscription processed', {
+    session: checkoutSession.id,
+    subscription: subscription?.id,
+    isNew: !existingSubscriptionId,
+  });
+
+  return {
+    subscriptions: subscription ? [subscription] : [],
+    subscriptionGroups: {},
+    primarySubscription: subscription,
+  };
+}
+
+/**
+ * Creates multiple subscriptions grouped by price ID
+ */
+async function createMultipleSubscriptions(params: {
+  checkoutSession: CheckoutSession;
+  lineItems: TLineItemExpanded[];
+  customer: Customer;
+  paymentSettings: { method: PaymentMethod; currency: PaymentCurrency };
+  setupIntent: SetupIntent | null;
+  trialConfig?: { trialInDays?: number; trialEnd?: number };
+}) {
+  const { checkoutSession, lineItems, customer, paymentSettings, setupIntent, trialConfig } = params;
+
+  // Group items by price ID
+  const priceGroups = groupLineItemsByPrice(lineItems);
+  const existingGroups = checkoutSession.subscription_groups || {};
+
+  const subscriptions: any[] = [];
+  const subscriptionGroups: Record<string, string> = {};
+  let primarySubscription: any = null;
+
+  const noStake = !!checkoutSession.subscription_data?.no_stake;
+  const billingThreshold = getBillingThreshold(checkoutSession.subscription_data);
+  const minStakeAmount = getMinStakeAmount(checkoutSession.subscription_data);
+
+  // Create a task for each price group
+  const tasks = Object.entries(priceGroups).map(([priceId, items], index) => async () => {
+    try {
+      const existingSubscriptionId = existingGroups[priceId];
+      const isPrimary = index === 0;
+      const subscriptionMetadata = {
+        price_id: priceId,
+        checkout_session_id: checkoutSession.id,
+        ...(isPrimary ? { is_primary_subscription: true } : {}),
+      };
+
+      const subscriptionItems = items;
+
+      // Set different stake configurations for different subscriptions
+      let billingThresholds = {};
+      if (isPrimary) {
+        billingThresholds = {
+          amount_gte: billingThreshold,
+          stake_gte: minStakeAmount,
+          reset_billing_cycle_anchor: false,
+          no_stake: noStake,
+        };
+      } else {
+        // if not primary subscription, set stake to 0
+        billingThresholds = {
+          amount_gte: 0,
+          stake_gte: 0,
+          reset_billing_cycle_anchor: false,
+          no_stake: true,
+          references_primary_stake: true,
+        };
+      }
+
+      const subscription = await createOrUpdateSubscription({
+        existingSubscriptionId,
+        checkoutSession,
+        lineItems: subscriptionItems,
+        customer,
+        paymentSettings,
+        setupIntent,
+        trialConfig,
+        metadata: subscriptionMetadata,
+        billing_thresholds: billingThresholds as SubscriptionBillingThresholds,
+      });
+
+      if (!subscription) {
+        return { success: false, priceId, error: 'Failed to create subscription' };
+      }
+
+      return { success: true, priceId, subscription, isPrimary };
+    } catch (error) {
+      logger.error('Failed to create subscription for price group', {
+        priceId,
+        error: error.message,
+        session: checkoutSession.id,
+        stack: error.stack,
+      });
+      return { success: false, priceId, error: error.message };
+    }
+  });
+
+  const results = await pAll(tasks, { concurrency: 5 });
+
+  results.forEach((result) => {
+    if (result.success && result.subscription) {
+      subscriptionGroups[result.priceId] = result.subscription.id;
+      subscriptions.push(result.subscription);
+      if (result.isPrimary) {
+        primarySubscription = result.subscription;
+      }
+    }
+  });
+
+  return {
+    subscriptions,
+    subscriptionGroups,
+    primarySubscription,
+  };
+}
+
+/**
+ * Core logic for creating or updating a single subscription
+ */
+async function createOrUpdateSubscription(params: {
+  existingSubscriptionId?: string | null;
+  checkoutSession: CheckoutSession;
+  lineItems: TLineItemExpanded[];
+  customer: Customer;
+  paymentSettings: { method: PaymentMethod; currency: PaymentCurrency };
+  setupIntent: SetupIntent | null;
+  trialConfig?: { trialInDays?: number; trialEnd?: number };
+  metadata?: Record<string, any>;
+  billing_thresholds?: SubscriptionBillingThresholds;
+}): Promise<any> {
+  const {
+    existingSubscriptionId,
+    checkoutSession,
+    lineItems,
+    customer,
+    paymentSettings,
+    setupIntent,
+    trialConfig = {},
+    metadata = {},
+    billing_thresholds: billingThresholds,
+  } = params;
+
+  const { trialInDays = 0, trialEnd = 0 } = trialConfig;
+  const { method: paymentMethod, currency: paymentCurrency } = paymentSettings;
+
+  try {
+    const itemsSubscriptionData = mergeSubscriptionDataFromLineItems(lineItems);
+    let subscription = null;
+    const setup = getSubscriptionCreateSetup(lineItems, paymentCurrency.id, trialInDays, trialEnd);
+
+    if (existingSubscriptionId) {
+      subscription = await Subscription.findByPk(existingSubscriptionId);
+    }
+
+    if (subscription) {
+      // Validate subscription status
+      if (subscription.status !== 'incomplete') {
+        throw new Error(`Subscription ${subscription.id} status not incomplete: ${subscription.status}`);
+      }
+
+      const billingCycleAnchor =
+        itemsSubscriptionData?.billing_cycle_anchor ||
+        checkoutSession.subscription_data?.billing_cycle_anchor ||
+        setup.cycle.anchor;
+
+      // Update existing subscription
+      subscription = await subscription.update({
+        currency_id: paymentCurrency.id,
+        customer_id: customer.id,
+        default_payment_method_id: paymentMethod.id,
+        current_period_start: setup.period.start,
+        current_period_end: setup.period.end,
+        billing_cycle_anchor: billingCycleAnchor,
+        trial_end: setup.trial.end,
+        trial_start: setup.trial.start,
+        pending_invoice_item_interval: setup.recurring,
+        pending_setup_intent: setupIntent?.id,
+      });
+
+      logger.info('Subscription updated', {
+        session: checkoutSession.id,
+        subscription: subscription.id,
+      });
+
+      // Rebuild subscription items
+      await SubscriptionItem.destroy({ where: { subscription_id: subscription.id } });
+      await createSubscriptionItems(subscription.id, lineItems, checkoutSession, itemsSubscriptionData);
+
+      // Update invoice customer if needed
+      const invoice = await Invoice.findByPk(subscription.latest_invoice_id);
+      if (invoice && invoice.customer_id !== customer.id) {
+        await invoice.update({ customer_id: customer.id });
+      }
+    } else {
+      // Create new subscription
+      const recoveredFromId =
+        itemsSubscriptionData.recovered_from || checkoutSession.subscription_data?.recovered_from || '';
+      const recoveredFrom = recoveredFromId ? await Subscription.findByPk(recoveredFromId) : null;
+
+      const safeMetadata = {
+        ...(checkoutSession.subscription_data?.notification_settings
+          ? {
+              notification_settings: checkoutSession.subscription_data.notification_settings,
+            }
+          : {}),
+        ...omit(checkoutSession.metadata || {}, ['days_until_due', 'days_until_cancel']),
+        ...(itemsSubscriptionData.metadata || {}),
+        ...metadata,
+      };
+
+      const subscriptionData = {
+        ...checkoutSession.subscription_data,
+        ...itemsSubscriptionData,
+      };
+
+      const subscriptionBillingThresholds = billingThresholds || {
+        amount_gte: getBillingThreshold(subscriptionData),
+        stake_gte: getMinStakeAmount(subscriptionData),
+        reset_billing_cycle_anchor: false,
+        no_stake: subscriptionData.no_stake,
+      };
+
+      subscription = await Subscription.create({
+        livemode: !!checkoutSession.livemode,
+        currency_id: paymentCurrency.id,
+        customer_id: customer.id,
+        status: 'incomplete',
+        current_period_start: setup.period.start,
+        current_period_end: setup.period.end,
+        // FIXME: billing_cycle_anchor implementation is not aligned with stripe
+        billing_cycle_anchor: subscriptionData.billing_cycle_anchor || setup.cycle.anchor,
+        start_date: dayjs().unix(),
+        trial_end: setup.trial.end,
+        trial_start: setup.trial.start,
+        trial_settings: {
+          end_behavior: {
+            missing_payment_method: 'create_invoice',
+          },
+        },
+        billing_thresholds: subscriptionBillingThresholds,
+        pending_invoice_item_interval: setup.recurring,
+        pending_setup_intent: setupIntent?.id,
+        default_payment_method_id: paymentMethod.id,
+        cancel_at_period_end: false,
+        collection_method: 'charge_automatically',
+        description: subscriptionData.description || formatSubscriptionProduct(lineItems),
+        proration_behavior: subscriptionData.proration_behavior || 'none',
+        payment_behavior: 'default_incomplete',
+        days_until_due: subscriptionData.days_until_due,
+        days_until_cancel: subscriptionData.days_until_cancel,
+        recovered_from: recoveredFrom?.id,
+        metadata: safeMetadata,
+        service_actions: subscriptionData.service_actions || [],
+      });
+
+      logger.info('Subscription created', {
+        session: checkoutSession.id,
+        subscription: subscription.id,
+      });
+
+      // Create subscription items with item-specific metadata
+      await createSubscriptionItems(subscription.id, lineItems, checkoutSession, itemsSubscriptionData);
+    }
+
+    return subscription;
+  } catch (error) {
+    logger.error('Failed in createOrUpdateSubscription', {
+      existingSubscriptionId,
+      error: error.message,
+      stack: error.stack,
+      session: checkoutSession.id,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Creates subscription items for a subscription
+ */
+async function createSubscriptionItems(
+  subscriptionId: string,
+  lineItems: TLineItemExpanded[],
+  checkoutSession: CheckoutSession,
+  itemsSubscriptionData: Record<string, any>
+) {
+  try {
+    const metadata = {
+      ...(itemsSubscriptionData?.metadata || {}),
+      ...(checkoutSession.metadata || {}),
+    };
+
+    const subItems = await Promise.all(
+      lineItems.map((item) =>
+        SubscriptionItem.create({
+          livemode: !!checkoutSession.livemode,
+          subscription_id: subscriptionId,
+          price_id: item.upsell_price_id || item.price_id,
+          quantity: item.quantity,
+          metadata,
+        })
+      )
+    );
+
+    logger.info('Subscription items created', {
+      session: checkoutSession.id,
+      subscription: subscriptionId,
+      items: subItems.map((x) => x.id),
+    });
+
+    return subItems;
+  } catch (error) {
+    logger.error('Failed to create subscription items', {
+      subscriptionId,
+      error: error.message,
+      stack: error.stack,
+      session: checkoutSession.id,
+    });
+    throw error;
+  }
+}
+
+/**
+ * Groups line items by price ID
+ */
+function groupLineItemsByPrice(lineItems: TLineItemExpanded[]): Record<string, TLineItemExpanded[]> {
+  const groups: Record<string, TLineItemExpanded[]> = {};
+  const recurringLineItems = getRecurringLineItems(lineItems);
+
+  recurringLineItems.forEach((item) => {
+    const priceId = item.upsell_price_id || item.price_id;
+    if (!groups[priceId]) {
+      groups[priceId] = [];
+    }
+    groups[priceId].push(item);
+  });
+
+  return groups;
+}
+
+export function getCheckoutSessionSubscriptionIds(checkoutSession: CheckoutSession) {
+  const enableGrouping = checkoutSession.enable_subscription_grouping;
+  if (!enableGrouping && checkoutSession.subscription_id) {
+    return [checkoutSession.subscription_id];
+  }
+  return Object.values(checkoutSession.subscription_groups || {}).filter(Boolean);
+}
+
+export function getOneTimeLineItems(lineItems: TLineItemExpanded[]) {
+  return lineItems.filter((item) => item.price?.type === 'one_time');
+}
+
+export function getRecurringLineItems(lineItems: TLineItemExpanded[]) {
+  return lineItems.filter((item) => item.price?.type === 'recurring');
+}
+
+export function mergeSubscriptionDataFromLineItems(lineItems: TLineItemExpanded[]): Record<string, any> {
+  if (lineItems.length === 0) {
+    return {};
+  }
+  const mergedData: Record<string, any> = {};
+  const mergedMetadata: Record<string, any> = {};
+  lineItems.forEach((item: TLineItemExpanded) => {
+    const subData = (item.subscription_data || {}) as any;
+    if (subData.metadata) {
+      Object.assign(mergedMetadata, subData.metadata);
+    }
+    Object.entries(subData).forEach(([key, value]) => {
+      if (key !== 'metadata') {
+        mergedData[key] = value;
+      }
+    });
+  });
+
+  if (Object.keys(mergedMetadata).length > 0) {
+    mergedData.metadata = mergedMetadata;
+  }
+
+  return mergedData;
+}
+
+/**
+ * Get line items related to a specific subscription
+ * @param subscription The subscription object
+ * @param lineItems All line items from checkout session
+ * @param primarySubscription Optional primary subscription to check one-time items
+ * @returns Line items associated with the subscription
+ */
+export async function getSubscriptionLineItems(
+  subscription: Subscription,
+  lineItems: TLineItemExpanded[],
+  primarySubscription?: Subscription
+): Promise<TLineItemExpanded[]> {
+  const subscriptionItems = await SubscriptionItem.findAll({
+    where: { subscription_id: subscription.id },
+  });
+
+  let subItems = lineItems.filter((x) =>
+    subscriptionItems.some((y) => y.price_id === x.price_id || y.price_id === x.upsell_price_id)
+  );
+
+  // Add one-time items if this is the primary subscription
+  if (primarySubscription && subscription.id === primarySubscription.id) {
+    subItems = [...subItems, ...getOneTimeLineItems(lineItems)];
+  }
+
+  return subItems;
+}