payment-kit 1.13.157 → 1.13.159

package/api/src/libs/lock.ts

@@ -0,0 +1,53 @@
+const { EventEmitter } = require('events');
+
+export class Lock {
+  name: string;
+  locked: boolean;
+  events: typeof EventEmitter;
+
+  constructor(name: string) {
+    this.name = name;
+    this.locked = false;
+    this.events = new EventEmitter();
+  }
+
+  acquire() {
+    return new Promise((resolve) => {
+      // If somebody has the lock, wait until he/she releases the lock and try again
+      if (this.locked) {
+        const tryAcquire = () => {
+          if (!this.locked) {
+            this.locked = true;
+            this.events.removeListener('release', tryAcquire);
+            resolve(true);
+          }
+        };
+
+        this.events.on('release', tryAcquire);
+      } else {
+        // Otherwise, take the lock and resolve immediately
+        this.locked = true;
+        resolve(true);
+      }
+    });
+  }
+
+  release() {
+    // Release the lock immediately
+    this.locked = false;
+    setImmediate(() => this.events.emit('release'));
+  }
+}
+
+const locks = new Map<string, Lock>();
+export function getLock(name: string): Lock {
+  const exist = locks.get(name);
+  if (exist instanceof Lock) {
+    return exist;
+  }
+
+  const lock = new Lock(name);
+  locks.set(name, lock);
+
+  return lock;
+}

package/api/src/libs/notification/template/one-time-payment-succeeded.ts

@@ -138,11 +138,11 @@ export class OneTimePaymentSucceededEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.oneTimePaymentSucceeded.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.oneTimePaymentSucceeded.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
       })}`,
       // @ts-expect-error
       attachments: [

package/api/src/libs/notification/template/subscription-cacceled.ts

@@ -137,11 +137,11 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionCanceled.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionCanceled.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
       })}`,
       // @ts-expect-error
       attachments: [

package/api/src/libs/notification/template/subscription-refund-succeeded.ts

@@ -161,11 +161,11 @@ export class SubscriptionRefundSucceededEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionRefundSucceeded.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionRefundSucceeded.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
         refundInfo,
       })}`,
       // @ts-expect-error

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

@@ -176,11 +176,11 @@ export class SubscriptionRenewFailedEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionRenewFailed.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionRenewFailed.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
         reason: `${reason}`,
       })}`,
       // @ts-expect-error

package/api/src/libs/notification/template/subscription-renewed.ts

@@ -165,11 +165,11 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionRenewed.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionRenewed.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
       })}`,
       // @ts-expect-error
       attachments: [

package/api/src/libs/notification/template/subscription-succeeded.ts

@@ -185,11 +185,11 @@ export class SubscriptionSucceededEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionSucceed.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionSucceed.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
       })}`,
       // @ts-expect-error
       attachments: [

package/api/src/libs/notification/template/subscription-trial-start.ts

@@ -161,11 +161,11 @@ export class SubscriptionTrailStartEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionTrialStart.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionTrialStart.body', locale, {
         subscriptionTrialEnd,
-        productName: `(${productName})`,
+        productName,
         trialDuration: duration,
       })}`,
       // @ts-expect-error

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

@@ -161,18 +161,18 @@ export class SubscriptionTrailWilEndEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionTrialWillEnd.title', locale, {
-        productName: `(${productName})`,
+        productName,
         willRenewDuration,
       })}`,
       body: canPay
         ? `${translate('notification.subscriptionTrialWillEnd.body', locale, {
             at,
-            productName: `(${productName})`,
+            productName,
             willRenewDuration,
           })}`
         : `${translate('notification.subscriptionTrialWillEnd.unableToPayBody', locale, {
             at,
-            productName: `(${productName})`,
+            productName,
             willRenewDuration,
             balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
             price: `${paymentDetail.price} ${paymentDetail.symbol}`,

package/api/src/libs/notification/template/subscription-upgraded.ts

@@ -154,11 +154,11 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionUpgraded.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: `${translate('notification.subscriptionUpgraded.body', locale, {
         at,
-        productName: `(${productName})`,
+        productName,
       })}`,
       // @ts-expect-error
       attachments: [

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

@@ -145,7 +145,7 @@ export class SubscriptionWillCanceledEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptWillCanceled.title', locale, {
-        productName: `(${productName})`,
+        productName,
       })}`,
       body: translate('notification.subscriptWillCanceled.body', locale, {
         productName,

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

@@ -181,18 +181,18 @@ export class SubscriptionWillRenewEmailTemplate
 
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionWillRenew.title', locale, {
-        productName: `(${productName})`,
+        productName,
         willRenewDuration,
       })}`,
       body: canPay
         ? `${translate('notification.subscriptionWillRenew.body', locale, {
             at,
-            productName: `(${productName})`,
+            productName,
             willRenewDuration,
           })}`
         : `${translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
             at,
-            productName: `(${productName})`,
+            productName,
             willRenewDuration,
             balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
             price: `${paymentDetail.price} ${paymentDetail.symbol}`,

package/api/src/libs/queue/index.ts

@@ -112,7 +112,8 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
           emit('queued', { id: jobId, job, attrs });
         })
         .catch((err) => {
-          logger.error('Can not add scheduled job to store', { error: err });
+          console.error(err);
+          logger.error('Can not add scheduled job to store', { jobId, job, attrs, error: err });
         });
 
       // @ts-ignore

package/api/src/libs/subscription.ts

@@ -35,18 +35,23 @@ export function getCustomerSubscriptionPageUrl({
   );
 }
 
-// FIXME: make this configurable from preferences
-export function getDaysUntilDue(query: Record<string, any> = {}): number | null {
-  const raw = query.days_until_due || process.env.PAYMENT_DAYS_UNTIL_DUE;
-  if (raw) {
+export function parseIntegerConfig(alternatives: any[], defaultValue: number) {
+  for (const raw of alternatives) {
     const days = parseInt(raw, 10);
-    // eslint-disable-next-line no-restricted-globals
-    if (isNaN(days) === false) {
+    if (typeof days === 'number' && days >= 0) {
       return days;
     }
   }
 
-  return 6;
+  return defaultValue;
+}
+
+export function getDaysUntilDue(query: Record<string, any> = {}) {
+  return parseIntegerConfig([query.days_until_due, process.env.PAYMENT_DAYS_UNTIL_DUE], 6);
+}
+
+export function getDaysUntilCancel(query: Record<string, any> = {}) {
+  return parseIntegerConfig([query.days_until_cancel, process.env.PAYMENT_DAYS_UNTIL_CANCEL], 0);
 }
 
 export const getDueUnit = (interval: string) => {
@@ -286,3 +291,27 @@ export async function getSubscriptionRefundSetup(subscription: Subscription, anc
   const setup = getSubscriptionCreateSetup(expanded, subscription.currency_id, 0);
   return createProration(subscription, setup, anchor);
 }
+
+export function shouldCancelSubscription(
+  subscription: Pick<Subscription, 'status' | 'current_period_end' | 'cancel_at'>
+) {
+  if (['past_due', 'active', 'trialing'].includes(subscription.status)) {
+    const now = dayjs().unix();
+    if (subscription.cancel_at) {
+      if (subscription.cancel_at <= now) {
+        return true;
+      }
+    } else if (subscription.current_period_end <= now) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export function formatSubscriptionProduct(items: TLineItemExpanded[], maxLength = 3) {
+  const names = items.map((x) => x.price?.product?.name).filter(Boolean);
+  return (
+    names.slice(0, maxLength).join(', ') + (names.length > maxLength ? ` and ${names.length - maxLength} more` : '')
+  );
+}

package/api/src/queues/payment.ts

@@ -1,3 +1,5 @@
+import isEmpty from 'lodash/isEmpty';
+
 import { ensureStakedForGas } from '../integrations/blockchain/stake';
 import { createEvent } from '../libs/audit';
 import { wallet } from '../libs/auth';
@@ -7,7 +9,15 @@ import { events } from '../libs/event';
 import logger from '../libs/logger';
 import { getGasPayerExtra, isDelegationSufficientForPayment } from '../libs/payment';
 import createQueue from '../libs/queue';
-import { getDaysUntilDue, getDueUnit, getMaxRetryCount, getMinRetryMail } from '../libs/subscription';
+import {
+  getDaysUntilCancel,
+  getDaysUntilDue,
+  getDueUnit,
+  getMaxRetryCount,
+  getMinRetryMail,
+  getSubscriptionCreateSetup,
+  shouldCancelSubscription,
+} from '../libs/subscription';
 import { MAX_RETRY_COUNT, MIN_RETRY_MAIL, getNextRetry } from '../libs/util';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -15,7 +25,9 @@ import { Invoice } from '../store/models/invoice';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { PaymentMethod } from '../store/models/payment-method';
+import { Price } from '../store/models/price';
 import { Subscription } from '../store/models/subscription';
+import { SubscriptionItem } from '../store/models/subscription-item';
 import type { PaymentError, PaymentSettings } from '../store/models/types';
 
 type PaymentJob = {
@@ -59,18 +71,44 @@ export const handlePaymentSucceed = async (paymentIntent: PaymentIntent) => {
     const subscription = await Subscription.findByPk(invoice.subscription_id);
 
     // We only update subscription status when the invoice is the latest one
-    if (subscription && invoice.id === subscription.latest_invoice_id) {
-      if (subscription.status === 'incomplete') {
+    if (subscription) {
+      if (subscription.status === 'incomplete' && invoice.id === subscription.latest_invoice_id) {
         await subscription.start();
         logger.info(`Subscription ${subscription.id} updated on payment done ${invoice.id}`);
-      } else if (subscription.status === 'past_due') {
-        if (subscription.cancel_at_period_end && subscription.cancelation_details?.reason === 'payment_failed') {
-          // @ts-ignore
-          await subscription.update({ status: 'active', cancel_at_period_end: false, cancelation_details: null });
-          logger.info(`Subscription ${subscription.id} moved to active after payment done ${paymentIntent.id}`);
-        } else {
-          await subscription.update({ status: 'active' });
-          logger.info(`Subscription ${subscription.id} moved to active after payment done ${paymentIntent.id}`);
+      } else if (subscription.status === 'past_due' && subscription.cancelation_details?.reason === 'payment_failed') {
+        // ensure no uncollectible amount before recovering from payment failed
+        const result = await Invoice.getUncollectibleAmountBySubscription(subscription.id);
+        if (isEmpty(result)) {
+          // reset billing cycle anchor and cancel_* if we are recovering from payment failed
+          if (subscription.cancel_at && subscription.cancel_at !== subscription.current_period_end) {
+            const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+            const lineItems = await Price.expand(subscriptionItems.map((x) => x.toJSON()));
+            const setup = getSubscriptionCreateSetup(lineItems, subscription.currency_id, 0);
+            await subscription.update({
+              status: 'active',
+              pending_invoice_item_interval: setup.recurring,
+              current_period_start: setup.period.start,
+              current_period_end: setup.period.end,
+              billing_cycle_anchor: setup.cycle.anchor,
+              cancel_at: 0,
+              cancel_at_period_end: false,
+              // @ts-ignore
+              cancelation_details: null,
+            });
+
+            createEvent('Subscription', 'customer.subscription.recovered', subscription).catch(console.error);
+            logger.info(
+              `Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel and billing cycle reset`
+            );
+          } else if (subscription.cancel_at_period_end) {
+            // reset cancel_at_period_end if we are recovering from payment failed
+            // @ts-ignore
+            await subscription.update({ status: 'active', cancel_at_period_end: false, cancelation_details: null });
+            logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel reset`);
+          } else {
+            await subscription.update({ status: 'active' });
+            logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}`);
+          }
         }
       }
 
@@ -155,7 +193,7 @@ export const handlePaymentFailed = async (
   }
 
   // check current period
-  if (subscription.current_period_end <= now) {
+  if (shouldCancelSubscription(subscription)) {
     await subscription.update({
       status: 'canceled',
       canceled_at: now,
@@ -174,17 +212,26 @@ export const handlePaymentFailed = async (
     return updates.terminate;
   }
 
+  // check days until cancel
+  const dueUnit = getDueUnit(interval);
+  const daysUntilCancel = getDaysUntilCancel(subscription);
+  const cancelUpdates: { [key: string]: any } = {};
+  if (daysUntilCancel > 0) {
+    cancelUpdates.cancel_at = subscription.current_period_start + daysUntilCancel * dueUnit;
+  } else {
+    cancelUpdates.cancel_at_period_end = true;
+  }
+
   // check days until due
   const daysUntilDue = getDaysUntilDue(subscription);
   if (typeof daysUntilDue === 'number') {
-    const dueUnit = getDueUnit(interval);
     const gracePeriodStart = subscription.current_period_start;
     const graceDuration = daysUntilDue ? daysUntilDue * dueUnit : 0;
     logger.debug('handlePaymentFailed.checkDue', { now, daysUntilDue, dueUnit, gracePeriodStart, graceDuration });
     if (gracePeriodStart + graceDuration <= now) {
       await subscription.update({
         status: 'past_due',
-        cancel_at_period_end: true,
+        ...cancelUpdates,
         cancelation_details: {
           comment: 'past_due',
           feedback: 'other',
@@ -207,7 +254,7 @@ export const handlePaymentFailed = async (
   if (invoice.attempt_count > maxRetry) {
     await subscription.update({
       status: 'past_due',
-      cancel_at_period_end: true,
+      ...cancelUpdates,
       cancelation_details: {
         comment: 'exceed_max_retry',
         feedback: 'other',

package/api/src/queues/subscription.ts

@@ -3,6 +3,7 @@ import type { LiteralUnion } from 'type-fest';
 import { ensurePassportRevoked } from '../integrations/blocklet/passport';
 import dayjs from '../libs/dayjs';
 import { events } from '../libs/event';
+import { getLock } from '../libs/lock';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
 import { getStatementDescriptor } from '../libs/session';
@@ -23,7 +24,7 @@ type SubscriptionJob = {
 
 const EXPECTED_SUBSCRIPTION_STATUS = ['trialing', 'active', 'paused', 'past_due'];
 
-export const handleSubscriptionInvoice = async ({
+const doHandleSubscriptionInvoice = async ({
   subscription,
   filter,
   status,
@@ -38,7 +39,7 @@ export const handleSubscriptionInvoice = async ({
   subscription: Subscription;
   filter: (x: any) => boolean;
   status: string;
-  reason: 'cycle' | 'cancel' | 'threshold';
+  reason: 'cycle' | 'cancel' | 'threshold' | 'recover';
   start: number;
   end: number;
   offset: number;
@@ -77,7 +78,7 @@ export const handleSubscriptionInvoice = async ({
   }
 
   // check if invoice already created for this reason
-  if (['cycle', 'cancel'].includes(reason)) {
+  if (['cycle', 'cancel', 'recover'].includes(reason)) {
     const exist = await Invoice.findOne({
       where: {
         subscription_id: subscription.id,
@@ -168,6 +169,14 @@ export const handleSubscriptionInvoice = async ({
   return invoice;
 };
 
+export async function handleSubscriptionInvoice(args: Parameters<typeof doHandleSubscriptionInvoice>[0]) {
+  const lock = getLock(`${args.subscription.id}-invoice`);
+  await lock.acquire();
+  const result = await doHandleSubscriptionInvoice(args);
+  lock.release();
+  return result;
+}
+
 const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
   const invoice = await handleSubscriptionInvoice({
     subscription,
@@ -241,6 +250,32 @@ const handleSubscriptionWhenActive = async (subscription: Subscription) => {
   }
 };
 
+const handleSubscriptionAfterRecover = async (subscription: Subscription) => {
+  const invoice = await handleSubscriptionInvoice({
+    subscription,
+    filter: () => true, // include all items
+    status: 'open',
+    reason: 'recover',
+    start: subscription.current_period_start,
+    end: subscription.current_period_end,
+    offset: 0,
+  });
+
+  if (invoice) {
+    // schedule invoice job
+    invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
+    logger.info(`Invoice job scheduled for initial billing cycle after recover: ${invoice.id}`);
+
+    // persist invoice id
+    await subscription.update({ latest_invoice_id: invoice.id });
+    logger.info(`Subscription updated for initial billing cycle after recover: ${subscription.id}`);
+  }
+
+  // schedule next billing cycle
+  await addSubscriptionJob(subscription, 'cycle', false, subscription.current_period_end);
+  logger.info(`Subscription job scheduled for next billing cycle after recover: ${subscription.id}`);
+};
+
 // generate invoice for subscription periodically
 export const handleSubscription = async (job: SubscriptionJob) => {
   logger.info('handle subscription', job);
@@ -315,18 +350,33 @@ export const subscriptionQueue = createQueue<SubscriptionJob>({
 });
 
 export const startSubscriptionQueue = async () => {
-  events.on('customer.subscription.deleted', (subscription: Subscription) => {
+  const pastDueHandler = async (subscription: Subscription) => {
+    await addSubscriptionJob(subscription, 'cancel', true, subscription.cancel_at || subscription.current_period_end);
+    logger.info('subscription cancel job scheduled after past_due', {
+      subscription: subscription.id,
+      runAt: subscription.cancel_at || subscription.current_period_end,
+    });
+  };
+
+  const recoverHandler = async (subscription: Subscription) => {
+    logger.info('subscription cancel job replaced after recover', { subscription: subscription.id });
+    await subscriptionQueue.delete(`cancel-${subscription.id}`);
+    await subscriptionQueue.delete(subscription.id);
+    const doc = await Subscription.findByPk(subscription.id);
+    await handleSubscriptionAfterRecover(doc!);
+  };
+
+  const cancelHandler = (subscription: Subscription) => {
     ensurePassportRevoked(subscription).catch((err) => {
       logger.error('ensurePassportRevoked failed', { error: err, subscription: subscription.id });
     });
 
     // FIXME: ensure invoices that are open or uncollectible are voided
-  });
+  };
 
-  events.on('customer.subscription.past_due', async (subscription: Subscription) => {
-    await addSubscriptionJob(subscription, 'cancel', true);
-    logger.info('subscription cancel job scheduled after past_due');
-  });
+  events.addListener('customer.subscription.past_due', pastDueHandler);
+  events.addListener('customer.subscription.recovered', recoverHandler);
+  events.addListener('customer.subscription.deleted', cancelHandler);
 
   const subscriptions = await Subscription.findAll({
     where: {

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

@@ -32,7 +32,12 @@ import {
   getSupportedPaymentMethods,
   isLineItemAligned,
 } from '../libs/session';
-import { getDaysUntilDue, getSubscriptionCreateSetup } from '../libs/subscription';
+import {
+  formatSubscriptionProduct,
+  getDaysUntilCancel,
+  getDaysUntilDue,
+  getSubscriptionCreateSetup,
+} from '../libs/subscription';
 import { CHECKOUT_SESSION_TTL, createCodeGenerator, formatMetadata, getDataObjectFromQuery } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
 import { paymentQueue } from '../queues/payment';
@@ -346,6 +351,7 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
           ...link.metadata,
           ...getDataObjectFromQuery(req.query),
           days_until_due: getDaysUntilDue(req.query),
+          days_until_cancel: getDaysUntilCancel(req.query),
           passport: await checkPassportForPaymentLink(link),
           preview: '1',
         };
@@ -355,6 +361,7 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
         ...link.metadata,
         ...getDataObjectFromQuery(req.query),
         days_until_due: getDaysUntilDue(req.query),
+        days_until_cancel: getDaysUntilCancel(req.query),
         passport: await checkPassportForPaymentLink(link),
       };
     }
@@ -612,7 +619,9 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         setupIntent = await SetupIntent.create({
           livemode: !!checkoutSession.livemode,
           customer_id: customer.id,
-          description: checkoutSession.payment_intent_data?.description || '',
+          description:
+            checkoutSession.payment_intent_data?.description ||
+            formatSubscriptionProduct(lineItems.filter((x) => x.price.type === 'recurring')),
           currency_id: paymentCurrency.id,
           payment_method_id: paymentMethod.id,
           status: 'requires_payment_method',
@@ -676,10 +685,13 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           default_payment_method_id: paymentMethod.id,
           cancel_at_period_end: false,
           collection_method: 'charge_automatically',
-          description: checkoutSession.subscription_data?.description || '',
+          description:
+            checkoutSession.subscription_data?.description ||
+            formatSubscriptionProduct(lineItems.filter((x) => x.price.type === 'recurring')),
           proration_behavior: checkoutSession.subscription_data?.proration_behavior || 'none',
           payment_behavior: 'default_incomplete',
           days_until_due: checkoutSession.metadata?.days_until_due,
+          days_until_cancel: checkoutSession.metadata?.days_until_cancel,
           metadata: checkoutSession.metadata as any,
         });