payment-kit 1.13.128 → 1.13.129

package/api/src/libs/session.ts

@@ -7,7 +7,6 @@ import type { TLineItemExpanded, TPaymentCurrency, TPaymentMethodExpanded } from
 import type { Price, TPrice } from '../store/models/price';
 import type { Product } from '../store/models/product';
 import type { PriceCurrency, PriceRecurring } from '../store/models/types';
-import dayjs from './dayjs';
 
 export function getStatementDescriptor(items: any[]) {
   for (const item of items) {
@@ -99,69 +98,6 @@ export function getRecurringPeriod(recurring: PriceRecurring) {
   }
 }
 
-export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currencyId: string, trialInDays = 0) {
-  let setup = new BN(0);
-
-  items.forEach((x) => {
-    const price = x.upsell_price || x.price;
-    const unit = getPriceUintAmountByCurrency(price, currencyId);
-    if (price.type === 'one_time' || (price.type === 'recurring' && price.recurring?.usage_type === 'licensed')) {
-      setup = setup.add(new BN(unit).mul(new BN(x.quantity)));
-    }
-  });
-
-  const item = items.find((x) => x.price.type === 'recurring');
-  const recurring = (item?.upsell_price || item?.price)?.recurring as PriceRecurring;
-  const cycle = getRecurringPeriod(recurring);
-  const trial = trialInDays ? trialInDays * 24 * 60 * 60 * 1000 : 0;
-
-  return {
-    recurring,
-    cycle: {
-      duration: cycle,
-      anchor: trialInDays ? dayjs().add(trial, 'millisecond').unix() : dayjs().unix(),
-    },
-    trail: {
-      start: trialInDays ? dayjs().unix() : 0,
-      end: trialInDays ? dayjs().add(trial, 'millisecond').unix() : 0,
-    },
-    period: {
-      start: dayjs().unix(),
-      end: dayjs()
-        .add(trialInDays ? trial : cycle, 'millisecond')
-        .unix(),
-    },
-    amount: {
-      setup: setup.toString(),
-    },
-  };
-}
-
-export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPeriodEnd: number) {
-  const cycle = getRecurringPeriod(recurring);
-
-  return {
-    recurring,
-    cycle,
-    period: {
-      start: previousPeriodEnd,
-      end: dayjs.unix(previousPeriodEnd).add(cycle, 'millisecond').unix(),
-    },
-  };
-}
-
-export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currencyId: string) {
-  let amount = new BN(0);
-
-  items.forEach((x) => {
-    amount = amount.add(new BN(getPriceUintAmountByCurrency(x.price, currencyId)).mul(new BN(x.quantity)));
-  });
-
-  return {
-    total: amount.toString(),
-  };
-}
-
 export function expandLineItems(items: any[], products: Product[], prices: Price[]) {
   items.forEach((item) => {
     item.price = prices.find((x) => x.id === item.price_id);
@@ -230,7 +166,10 @@ export function isLineItemRecurringAligned(list: TLineItemExpanded[], index: num
     }
 
     // If the interval and interval_count are different, the recurring is not aligned
-    if (recurring?.interval !== x.recurring?.interval || recurring?.interval_count !== x.recurring?.interval_count) {
+    if (
+      String(recurring?.interval) !== String(x.recurring?.interval) ||
+      Number(recurring?.interval_count) !== Number(x.recurring?.interval_count)
+    ) {
       return false;
     }
 

package/api/src/libs/subscription.ts

@@ -1,4 +1,9 @@
-import { component } from '@blocklet/sdk';
+import component from '@blocklet/sdk/lib/component';
+import { BN } from '@ocap/util';
+
+import type { PriceRecurring, TLineItemExpanded } from '../store/models';
+import dayjs from './dayjs';
+import { getPriceUintAmountByCurrency, getRecurringPeriod } from './session';
 
 export function getCustomerSubscriptionPageUrl(subscriptionId: string, locale: string = 'en') {
   return component.getUrl(`customer/subscription/${subscriptionId}?locale=${locale}`);
@@ -61,3 +66,66 @@ export const getMinRetryMail = (interval: string) => {
 
   return 15; // 18 hours
 };
+
+export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currencyId: string, trialInDays = 0) {
+  let setup = new BN(0);
+
+  items.forEach((x) => {
+    const price = x.upsell_price || x.price;
+    const unit = getPriceUintAmountByCurrency(price, currencyId);
+    if (price.type === 'one_time' || (price.type === 'recurring' && price.recurring?.usage_type === 'licensed')) {
+      setup = setup.add(new BN(unit).mul(new BN(x.quantity)));
+    }
+  });
+
+  const item = items.find((x) => x.price.type === 'recurring');
+  const recurring = (item?.upsell_price || item?.price)?.recurring as PriceRecurring;
+  const cycle = getRecurringPeriod(recurring);
+  const trial = trialInDays ? trialInDays * 24 * 60 * 60 * 1000 : 0;
+
+  return {
+    recurring,
+    cycle: {
+      duration: cycle,
+      anchor: trialInDays ? dayjs().add(trial, 'millisecond').unix() : dayjs().unix(),
+    },
+    trail: {
+      start: trialInDays ? dayjs().unix() : 0,
+      end: trialInDays ? dayjs().add(trial, 'millisecond').unix() : 0,
+    },
+    period: {
+      start: dayjs().unix(),
+      end: dayjs()
+        .add(trialInDays ? trial : cycle, 'millisecond')
+        .unix(),
+    },
+    amount: {
+      setup: setup.toString(),
+    },
+  };
+}
+
+export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPeriodEnd: number) {
+  const cycle = getRecurringPeriod(recurring);
+
+  return {
+    recurring,
+    cycle,
+    period: {
+      start: previousPeriodEnd,
+      end: dayjs.unix(previousPeriodEnd).add(cycle, 'millisecond').unix(),
+    },
+  };
+}
+
+export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currencyId: string) {
+  let amount = new BN(0);
+
+  items.forEach((x) => {
+    amount = amount.add(new BN(getPriceUintAmountByCurrency(x.price, currencyId)).mul(new BN(x.quantity)));
+  });
+
+  return {
+    total: amount.toString(),
+  };
+}

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

@@ -2,7 +2,7 @@
 import { Op } from 'sequelize';
 
 import { mintNftForCheckoutSession } from '../integrations/blockchain/nft';
-import { ensurePassportIssued, ensurePassportRevoked } from '../integrations/blocklet/passport';
+import { ensurePassportIssued } from '../integrations/blocklet/passport';
 import dayjs from '../libs/dayjs';
 import { events } from '../libs/event';
 import logger from '../libs/logger';
@@ -17,7 +17,6 @@ import {
   Subscription,
   SubscriptionItem,
 } from '../store/models';
-import { subscriptionQueue } from './subscription';
 
 type CheckoutSessionJob = {
   id: string;
@@ -88,22 +87,6 @@ export async function startCheckoutSessionQueue() {
     });
   });
 
-  events.on('customer.subscription.deleted', (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', (subscription: Subscription) => {
-    subscriptionQueue.push({
-      id: `cancel-${subscription.id}`,
-      job: { subscriptionId: subscription.id, action: 'cancel' },
-      runAt: subscription.current_period_end,
-    });
-  });
-
   events.on('checkout.session.created', (checkoutSession: CheckoutSession) => {
     if (checkoutSession.expires_at) {
       checkoutSessionQueue.push({

package/api/src/queues/subscription.ts

@@ -1,9 +1,12 @@
 import type { LiteralUnion } from 'type-fest';
 
+import { ensurePassportRevoked } from '../integrations/blocklet/passport';
 import dayjs from '../libs/dayjs';
+import { events } from '../libs/event';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { getStatementDescriptor, getSubscriptionCycleAmount, getSubscriptionCycleSetup } from '../libs/session';
+import { getStatementDescriptor } from '../libs/session';
+import { getSubscriptionCycleAmount, getSubscriptionCycleSetup } from '../libs/subscription';
 import { ensureInvoiceAndItems } from '../routes/connect/shared';
 import { PaymentCurrency, PaymentMethod, UsageRecord } from '../store/models';
 import { Customer } from '../store/models/customer';
@@ -20,15 +23,29 @@ type SubscriptionJob = {
 
 const EXPECTED_SUBSCRIPTION_STATUS = ['trialing', 'active', 'paused', 'past_due'];
 
-const handleSubscriptionInvoice = async (
-  subscription: Subscription,
-  filter: (x: any) => boolean,
-  status: string,
-  reason: 'cycle' | 'cancel',
-  start: number,
-  end: number,
-  offset: number
-) => {
+export const handleSubscriptionInvoice = async ({
+  subscription,
+  filter,
+  status,
+  reason,
+  start,
+  end,
+  offset,
+  usageStart,
+  usageEnd,
+  metadata,
+}: {
+  subscription: Subscription;
+  filter: (x: any) => boolean;
+  status: string;
+  reason: 'cycle' | 'cancel' | 'threshold';
+  start: number;
+  end: number;
+  offset: number;
+  usageStart?: number;
+  usageEnd?: number;
+  metadata?: Record<string, any>;
+}) => {
   // Do we still have the customer
   const customer = await Customer.findByPk(subscription.customer_id);
   if (!customer) {
@@ -59,18 +76,20 @@ const handleSubscriptionInvoice = async (
     }
   }
 
-  // check if invoice already created
-  const exist = await Invoice.findOne({
-    where: {
-      subscription_id: subscription.id,
-      period_start: start,
-      period_end: end,
-      billing_reason: `subscription_${reason}`,
-    },
-  });
-  if (exist) {
-    logger.warn(`Invoice already created for subscription ${subscription.id} for ${reason}: ${exist.id}`);
-    return null;
+  // check if invoice already created for this reason
+  if (['cycle', 'cancel'].includes(reason)) {
+    const exist = await Invoice.findOne({
+      where: {
+        subscription_id: subscription.id,
+        period_start: start,
+        period_end: end,
+        billing_reason: `subscription_${reason}`,
+      },
+    });
+    if (exist) {
+      logger.warn(`Invoice already created for subscription ${subscription.id} for ${reason}: ${exist.id}`);
+      return null;
+    }
   }
 
   // expand subscription items
@@ -86,21 +105,16 @@ const handleSubscriptionInvoice = async (
       // For metered billing, we need to get usage summary for this billing cycle
       // @link https://stripe.com/docs/products-prices/pricing-models#usage-types
       if (x.price.recurring?.usage_type === 'metered') {
-        const rawQuantity = await UsageRecord.getSummary(
-          x.id,
-          start - offset,
-          end - offset,
-          x.price.recurring?.aggregate_usage
-        );
-        if (x.price.transform_quantity) {
-          if (x.price.transform_quantity.round === 'up') {
-            x.quantity = Math.ceil(rawQuantity / x.price.transform_quantity.divide_by);
-          } else {
-            x.quantity = Math.floor(rawQuantity / x.price.transform_quantity.divide_by);
-          }
-        } else {
-          x.quantity = rawQuantity;
-        }
+        const rawQuantity = await UsageRecord.getSummary({
+          id: x.id,
+          start: (usageStart || start) - offset,
+          end: (usageEnd || end) - offset,
+          method: x.price.recurring?.aggregate_usage,
+          dryRun: false,
+        });
+
+        x.quantity = x.price.transformQuantity(rawQuantity);
+
         logger.info('Invoice.usageRecordSummary', {
           subscriptionId: subscription.id,
           subscriptionItemId: x.id,
@@ -108,8 +122,8 @@ const handleSubscriptionInvoice = async (
           transformQuantity: x.price.transform_quantity,
           rawQuantity,
           quantity: x.quantity,
-          start: start - offset,
-          end: end - offset,
+          start: (usageStart || start) - offset,
+          end: (usageEnd || end) - offset,
           usage: x.price.recurring?.aggregate_usage,
         });
 
@@ -147,7 +161,7 @@ const handleSubscriptionInvoice = async (
       total: amount.total,
       payment_settings: subscription.payment_settings,
       default_payment_method_id: subscription.default_payment_method_id,
-      metadata: {},
+      metadata,
     } as Invoice,
   });
 
@@ -155,15 +169,15 @@ const handleSubscriptionInvoice = async (
 };
 
 const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
-  const invoice = await handleSubscriptionInvoice(
+  const invoice = await handleSubscriptionInvoice({
     subscription,
-    (x) => x.price.recurring?.usage_type === 'metered', // include only metered items
-    'open',
-    'cancel',
-    subscription.current_period_start as number,
-    subscription.current_period_end as number,
-    0
-  );
+    filter: (x) => x.price.recurring?.usage_type === 'metered', // include only metered items
+    status: 'open',
+    reason: 'cancel',
+    start: subscription.current_period_start as number,
+    end: subscription.current_period_end as number,
+    offset: 0,
+  });
 
   if (invoice) {
     // schedule invoice job
@@ -196,15 +210,15 @@ const handleSubscriptionWhenActive = async (subscription: Subscription) => {
     }
   }
 
-  const invoice = await handleSubscriptionInvoice(
+  const invoice = await handleSubscriptionInvoice({
     subscription,
-    () => true, // include all items
+    filter: () => true, // include all items
     status,
-    'cycle',
-    setup.period.start,
-    setup.period.end,
-    setup.cycle / 1000
-  );
+    reason: 'cycle',
+    start: setup.period.start,
+    end: setup.period.end,
+    offset: setup.cycle / 1000,
+  });
 
   if (invoice) {
     // schedule invoice job
@@ -222,11 +236,7 @@ const handleSubscriptionWhenActive = async (subscription: Subscription) => {
 
   // schedule next billing cycle if we are not in terminal state
   if (subscription.isActive()) {
-    subscriptionQueue.push({
-      id: subscription.id,
-      job: { subscriptionId: subscription.id, action: 'cycle' },
-      runAt: setup.period.end,
-    });
+    await addSubscriptionJob(subscription, 'cycle', false, setup.period.end);
     logger.info(`Subscription job scheduled for next billing cycle: ${subscription.id}`);
   }
 };
@@ -277,20 +287,12 @@ export const handleSubscription = async (job: SubscriptionJob) => {
   // can we create new invoice for this subscription?
   if (subscription.status === 'trialing' && subscription.trail_end && subscription.trail_end > now) {
     logger.warn(`Subscription trialing period not ended: ${job.subscriptionId}`);
-    subscriptionQueue.push({
-      id: subscription.id,
-      job: { subscriptionId: subscription.id, action: 'cycle' },
-      runAt: subscription.trail_end,
-    });
+    await addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
     return;
   }
   if (subscription.status === 'active' && subscription.current_period_end > now) {
     logger.warn(`Subscription current period not ended: ${job.subscriptionId}`);
-    subscriptionQueue.push({
-      id: subscription.id,
-      job: { subscriptionId: subscription.id, action: 'cycle' },
-      runAt: subscription.current_period_end,
-    });
+    await addSubscriptionJob(subscription, 'cycle');
     return;
   }
 
@@ -313,6 +315,19 @@ export const subscriptionQueue = createQueue<SubscriptionJob>({
 });
 
 export const startSubscriptionQueue = async () => {
+  events.on('customer.subscription.deleted', (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');
+  });
+
   const subscriptions = await Subscription.findAll({
     where: {
       status: EXPECTED_SUBSCRIPTION_STATUS,
@@ -324,17 +339,40 @@ export const startSubscriptionQueue = async () => {
     if (supportAutoCharge === false) {
       return;
     }
-    const exist = await subscriptionQueue.get(x.id);
-    if (!exist) {
-      subscriptionQueue.push({
-        id: x.id,
-        job: { subscriptionId: x.id, action: 'cycle' },
-        runAt: x.current_period_end,
-      });
-    }
+    await addSubscriptionJob(x, 'cycle');
   });
 };
 
+export async function addSubscriptionJob(
+  subscription: Subscription,
+  action: 'cycle' | 'cancel' | 'resume',
+  replace?: boolean,
+  runAt?: number,
+  sync?: boolean
+) {
+  const fn = sync ? 'pushAndWait' : 'push';
+  const cycleJob = await subscriptionQueue.get(subscription.id);
+  if (replace && cycleJob) {
+    await subscriptionQueue.delete(subscription.id);
+    logger.info(`subscription cycle job replaced with ${action} job`, { subscription: subscription.id });
+  }
+  if (action === 'cycle') {
+    if (!cycleJob) {
+      await subscriptionQueue[fn]({
+        id: subscription.id,
+        job: { subscriptionId: subscription.id, action },
+        runAt: runAt || subscription.current_period_end,
+      });
+    }
+  } else {
+    await subscriptionQueue[fn]({
+      id: `${action}-${subscription.id}`,
+      job: { subscriptionId: subscription.id, action },
+      runAt: runAt || subscription.current_period_end,
+    });
+  }
+}
+
 subscriptionQueue.on('failed', ({ id, job, error }) => {
   logger.error('Subscription job failed', { id, job, error });
 });

package/api/src/queues/usage-record.ts

@@ -0,0 +1,155 @@
+import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
+
+import dayjs from '../libs/dayjs';
+import logger from '../libs/logger';
+import createQueue from '../libs/queue';
+import { getPriceUintAmountByCurrency } from '../libs/session';
+import {
+  Invoice,
+  PaymentCurrency,
+  Price,
+  SubscriptionItem,
+  TLineItemExpanded,
+  TPrice,
+  UsageRecord,
+} from '../store/models';
+import { Subscription } from '../store/models/subscription';
+import { invoiceQueue } from './invoice';
+import { handleSubscriptionInvoice } from './subscription';
+
+type UsageRecordJob = {
+  subscriptionId: string;
+  subscriptionItemId: string;
+};
+
+// FIXME: support subscription item level billing_thresholds
+// generate invoice for metered billing
+export const handleUsageRecord = async (job: UsageRecordJob) => {
+  logger.info('handle usage record', job);
+
+  const subscription = await Subscription.findByPk(job.subscriptionId);
+  if (!subscription) {
+    logger.warn('Subscription not found', job);
+    return;
+  }
+  if (subscription.isActive() === false) {
+    logger.warn('Subscription not active, so usage check is skipped', job);
+    return;
+  }
+  if (!subscription.billing_thresholds?.amount_gte) {
+    logger.warn('Subscription billing_threshold not set', job);
+    return;
+  }
+  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!currency) {
+    logger.warn('Subscription currency not found', job);
+    return;
+  }
+
+  const item = await SubscriptionItem.findByPk(job.subscriptionItemId);
+  if (!item) {
+    logger.warn('SubscriptionItem not found', job);
+    return;
+  }
+  // @ts-ignore
+  const lines = await Price.expand([{ id: item.id, price_id: item.price_id, quantity: item.quantity }], {
+    product: true,
+  });
+
+  const filter = (x: TLineItemExpanded) => x.price.recurring?.usage_type === 'metered';
+  const metered = lines.filter(filter);
+  if (!metered.length) {
+    logger.warn('SubscriptionItem not metered', job);
+    return;
+  }
+  const [expanded] = metered;
+
+  const start = subscription.current_period_start as number;
+  const end = subscription.current_period_end as number;
+  const latestThresholdInvoice = await Invoice.findOne({
+    where: {
+      subscription_id: subscription.id,
+      billing_reason: 'subscription_threshold',
+      period_start: start,
+      period_end: end,
+    },
+    order: [['created_at', 'DESC']],
+  });
+
+  let usageStart = start;
+  const usageEnd = dayjs().unix();
+  if (latestThresholdInvoice && latestThresholdInvoice.metadata) {
+    usageStart = latestThresholdInvoice.metadata.usage_end as number;
+  }
+
+  const rawQuantity = await UsageRecord.getSummary({
+    // @ts-ignore
+    id: expanded?.id as string,
+    start: usageStart,
+    end: usageEnd,
+    method: expanded?.price.recurring?.aggregate_usage as any,
+    dryRun: true,
+  });
+  // @ts-ignore
+  const quantity = expanded?.price.transformQuantity(rawQuantity);
+  const unitAmount = getPriceUintAmountByCurrency(expanded?.price as TPrice, subscription.currency_id);
+  const totalAmount = new BN(quantity).mul(new BN(unitAmount));
+  const threshold = fromTokenToUnit(subscription.billing_thresholds.amount_gte, currency.decimal);
+  logger.info('SubscriptionItem Usage check', {
+    subscriptionId: subscription.id,
+    subscriptionItemId: item.id,
+    start: dayjs.unix(start).toISOString(),
+    end: dayjs.unix(end).toISOString(),
+    usageStart: dayjs.unix(usageStart).toISOString(),
+    usageEnd: dayjs.unix(usageEnd).toISOString(),
+    rawQuantity,
+    quantity,
+    unitAmount: fromUnitToToken(unitAmount, currency.decimal),
+    totalAmount: fromUnitToToken(totalAmount.toString(), currency.decimal),
+    threshold: fromUnitToToken(threshold.toString(), currency.decimal),
+  });
+  if (totalAmount.lt(threshold)) {
+    logger.info('SubscriptionItem usage below threshold', job);
+    return;
+  }
+
+  logger.info('SubscriptionItem usage exceeds threshold', job);
+  const invoice = await handleSubscriptionInvoice({
+    subscription,
+    filter, // include only metered items
+    status: 'open',
+    reason: 'threshold',
+    start,
+    end,
+    offset: 0,
+    usageStart,
+    usageEnd,
+    metadata: {
+      usage_start: usageStart,
+      usage_end: usageEnd,
+    },
+  });
+
+  if (invoice) {
+    // schedule invoice job
+    invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
+    logger.info(`Invoice job scheduled on threshold: ${invoice.id}`);
+
+    // persist invoice id
+    await subscription.update({ latest_invoice_id: invoice.id });
+    logger.info(`Subscription updated on threshold: ${subscription.id}`);
+  }
+};
+
+export const usageRecordQueue = createQueue<UsageRecordJob>({
+  name: 'usage-record',
+  onJob: handleUsageRecord,
+  options: {
+    concurrency: 5,
+    maxRetries: 3,
+  },
+});
+
+usageRecordQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Usage job failed', { id, job, error });
+});

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

@@ -27,16 +27,15 @@ import {
   getCheckoutMode,
   getFastCheckoutAmount,
   getStatementDescriptor,
-  getSubscriptionCreateSetup,
   getSupportedPaymentCurrencies,
   getSupportedPaymentMethods,
   isLineItemAligned,
 } from '../libs/session';
-import { getDaysUntilDue } from '../libs/subscription';
+import { 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';
-import { subscriptionQueue } from '../queues/subscription';
+import { addSubscriptionJob } from '../queues/subscription';
 import type { TPriceExpanded, TProductExpanded } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -654,6 +653,10 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
               missing_payment_method: 'create_invoice',
             },
           },
+          // @ts-ignore
+          billing_thresholds: checkoutSession.subscription_data?.billing_threshold_amount
+            ? { amount_gte: +checkoutSession.subscription_data.billing_threshold_amount, reset_billing_cycle_anchor: false } // prettier-ignore
+            : null,
           pending_invoice_item_interval: setup.recurring,
           pending_setup_intent: setupIntent?.id,
           default_payment_method_id: paymentMethod.id,
@@ -759,11 +762,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         if (invoice) {
           invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
         }
-        subscriptionQueue.push({
-          id: subscription.id,
-          job: { subscriptionId: subscription.id, action: 'cycle' },
-          runAt: subscription.trail_end || subscription.current_period_end,
-        });
+        addSubscriptionJob(subscription, 'cycle', false, subscription.trail_end);
       }
     }