payment-kit 1.13.91 → 1.13.93

package/api/src/crons/index.ts

@@ -1,7 +1,8 @@
 import Cron from '@abtnode/cron';
 
-import { notificationCronTime } from '../libs/env';
+import { notificationCronTime, subscriptionCronTime } from '../libs/env';
 import logger from '../libs/logger';
+import { startSubscriptionQueue } from '../queues/subscription';
 import { SubscriptionTrailWillEndSchedule } from './subscription-trail-will-end';
 import { SubscriptionWillRenewSchedule } from './subscription-will-renew';
 
@@ -21,6 +22,12 @@ function init() {
         fn: () => new SubscriptionTrailWillEndSchedule().run(),
         options: { runOnInit: true },
       },
+      {
+        name: 'subscription.schedule.retry',
+        time: subscriptionCronTime,
+        fn: startSubscriptionQueue,
+        options: { runOnInit: false },
+      },
     ],
     onError: (error: Error, name: string) => {
       logger.error('run job failed', { name, error: error.message, stack: error.stack });

package/api/src/index.ts

@@ -26,6 +26,7 @@ import collectHandlers from './routes/connect/collect';
 import payHandlers from './routes/connect/pay';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
+import updateHandlers from './routes/connect/update';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
 
@@ -53,6 +54,7 @@ handlers.attach(Object.assign({ app: router }, collectHandlers));
 handlers.attach(Object.assign({ app: router }, payHandlers));
 handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));
+handlers.attach(Object.assign({ app: router }, updateHandlers));
 
 router.use('/api', routes);
 

package/api/src/libs/audit.ts

@@ -16,24 +16,21 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
 
-  const event = await Event.create(
-    {
-      type,
-      api_version: API_VERSION,
-      livemode: !!model.livemode,
-      object_id: model.id,
-      object_type: scope,
-      data,
-      request: {
-        // FIXME:
-        id: '',
-        idempotency_key: '',
-      },
-      metadata: {},
-      pending_webhooks: 99, // force all events goto the event queue
+  const event = await Event.create({
+    type,
+    api_version: API_VERSION,
+    livemode: !!model.livemode,
+    object_id: model.id,
+    object_type: scope,
+    data,
+    request: {
+      // FIXME:
+      id: '',
+      idempotency_key: '',
     },
-    { transaction: null }
-  );
+    metadata: {},
+    pending_webhooks: 99, // force all events goto the event queue
+  });
 
   events.emit('event.created', { id: event.id });
   events.emit(event.type, data.object);
@@ -61,24 +58,21 @@ export async function createStatusEvent(
   }
 
   const suffix = config[data.object.status];
-  const event = await Event.create(
-    {
-      type: [prefix, suffix].join('.'),
-      api_version: API_VERSION,
-      livemode: !!model.livemode,
-      object_id: model.id,
-      object_type: scope,
-      data,
-      request: {
-        // FIXME:
-        id: '',
-        idempotency_key: '',
-      },
-      metadata: {},
-      pending_webhooks: 99, // force all events goto the event queue
+  const event = await Event.create({
+    type: [prefix, suffix].join('.'),
+    api_version: API_VERSION,
+    livemode: !!model.livemode,
+    object_id: model.id,
+    object_type: scope,
+    data,
+    request: {
+      // FIXME:
+      id: '',
+      idempotency_key: '',
     },
-    { transaction: null }
-  );
+    metadata: {},
+    pending_webhooks: 99, // force all events goto the event queue
+  });
 
   events.emit('event.created', { id: event.id });
   events.emit(event.type, data.object);

package/api/src/libs/env.ts

@@ -1,5 +1,6 @@
 import env from '@blocklet/sdk/lib/env';
 
+export const subscriptionCronTime: string = process.env.SUBSCRIPTION_CRON_TIME || '0 */30 * * * *'; // 默认每 30 min 行一次
 export const notificationCronTime: string = process.env.NOTIFICATION_CRON_TIME || '0 5 */6 * * *'; // 默认每6个小时执行一次
 export const notificationCronConcurrency: number = Number(process.env.NOTIFICATION_CRON_CONCURRENCY) || 8; // 默认并发数为 8
 

package/api/src/libs/payment.ts

@@ -8,15 +8,7 @@ import { BN, fromUnitToToken } from '@ocap/util';
 import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
-import {
-  CheckoutSession,
-  Invoice,
-  PaymentCurrency,
-  PaymentIntent,
-  PaymentMethod,
-  TCustomer,
-  TLineItemExpanded,
-} from '../store/models';
+import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod, TCustomer, TLineItemExpanded } from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, wallet } from './auth';
 import { OCAP_PAYMENT_TX_TYPE } from './util';
@@ -209,7 +201,7 @@ export async function getPaymentDetail(userDid: string, invoice: Invoice): Promi
 }
 
 export async function getTokenLimitsForDelegation(
-  checkoutSession: CheckoutSession,
+  items: TLineItemExpanded[],
   paymentMethod: PaymentMethod,
   paymentCurrency: PaymentCurrency,
   address: string,
@@ -218,7 +210,6 @@ export async function getTokenLimitsForDelegation(
   const client = paymentMethod.getOcapClient();
   const { state } = await client.getDelegateState({ address });
 
-  const items = checkoutSession.line_items as TLineItemExpanded[];
   const hasMetered = items.some((x) => x.price.recurring?.usage_type === 'metered');
   const allowance = hasMetered ? '0' : amount;
 

package/api/src/libs/session.ts

@@ -109,7 +109,7 @@ export function getSubscriptionCreateSetup(items: TLineItemExpanded[], currencyI
     setup = setup.add(new BN(unit).mul(new BN(x.quantity)));
     if (price.type === 'recurring') {
       if (trialInDays === 0) {
-        subscription = setup.add(new BN(unit).mul(new BN(x.quantity)));
+        subscription = subscription.add(new BN(unit).mul(new BN(x.quantity)));
       }
     }
   });

package/api/src/libs/util.ts

@@ -152,15 +152,18 @@ export function getTxMetadata(extra: Record<string, any> = {}): any {
   };
 }
 
-export function getMetadataFromQuery(query: Record<string, any> = {}): Record<string, any> {
-  const metadata: Record<string, any> = {};
+export function getDataObjectFromQuery(
+  query: Record<string, any> = {},
+  prefix: string = 'metadata'
+): Record<string, any> {
+  const result: Record<string, any> = {};
   Object.keys(query).forEach((key) => {
-    if (key.startsWith('metadata.') && query[key]) {
-      metadata[key.replace('metadata.', '')] = query[key];
+    if (key.startsWith(`${prefix}.`) && query[key]) {
+      result[key.replace(`${prefix}.`, '')] = query[key];
     }
   });
 
-  return metadata;
+  return result;
 }
 
 // @FIXME: 这个应该封装在某个通用类库里面 @jianchao @wangshijun

package/api/src/queues/subscription.ts

@@ -20,116 +20,41 @@ type SubscriptionJob = {
 
 const EXPECTED_SUBSCRIPTION_STATUS = ['trialing', 'active', 'paused', 'past_due'];
 
-// generate invoice for subscription periodically
-export const handleSubscription = async (job: SubscriptionJob) => {
-  logger.info('handle subscription', job);
-
-  const subscription = await Subscription.findByPk(job.subscriptionId);
-  if (!subscription) {
-    logger.warn(`Subscription not found: ${job.subscriptionId}`);
-    return;
-  }
-  if (EXPECTED_SUBSCRIPTION_STATUS.includes(subscription.status) === false) {
-    logger.warn(`Subscription status not expected: ${job.subscriptionId}`);
-    return;
-  }
-  const supportAutoCharge = await PaymentMethod.supportAutoCharge(subscription.default_payment_method_id);
-  if (supportAutoCharge === false) {
-    logger.warn(`Subscription does not support auto charge: ${job.subscriptionId}`);
-    return;
-  }
-
-  const now = dayjs().unix();
-
-  // Do we need to cancel the subscription
-  if (subscription.isImmutable() === false) {
-    if (subscription.cancel_at_period_end) {
-      await subscription.update({ status: 'canceled', canceled_at: now });
-      logger.warn(`Subscription canceled on period end: ${job.subscriptionId}`);
-      return;
-    }
-    if (subscription.cancel_at && subscription.cancel_at <= now) {
-      await subscription.update({ status: 'canceled', canceled_at: now });
-      logger.warn(`Subscription canceled on schedule: ${job.subscriptionId}`);
-      return;
-    }
-  }
-
-  // Do we need to resume the subscription
-  if (subscription.pause_collection?.resumes_at && subscription.pause_collection?.resumes_at <= now) {
-    await subscription.update({ status: 'active', pause_collection: undefined });
-    logger.warn(`Subscription resumed as scheduled: ${job.subscriptionId}`);
-  }
-
-  // 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,
-    });
-    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,
-    });
-    return;
-  }
-
-  if (subscription.isActive() === false) {
-    logger.warn(`Subscription not active: ${job.subscriptionId}, so new invoice is skipped`);
-    return;
-  }
-
+const handleSubscriptionInvoice = async (
+  subscription: Subscription,
+  filter: (x: any) => boolean,
+  status: string,
+  reason: 'cycle' | 'cancel',
+  start: number,
+  end: number,
+  offset: number
+) => {
   // Do we still have the customer
   const customer = await Customer.findByPk(subscription.customer_id);
   if (!customer) {
     logger.warn(`Customer ${subscription.customer_id} not found for subscription: ${subscription.id}`);
-    return;
+    return null;
   }
 
   // Do we still have the currency
   const currency = await PaymentCurrency.findByPk(subscription.currency_id);
   if (!currency) {
     logger.warn(`Currency ${subscription.currency_id} not found for subscription: ${subscription.id}`);
-    return;
+    return null;
   }
 
-  // get setup for next subscription period
-  const previousPeriodEnd =
-    subscription.status === 'trialing' ? subscription.trail_end : subscription.current_period_end;
-  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
-
   // check if invoice already created
   const exist = await Invoice.findOne({
     where: {
       subscription_id: subscription.id,
-      period_start: setup.period.start,
-      period_end: setup.period.end,
+      period_start: start,
+      period_end: end,
+      billing_reason: `subscription_${reason}`,
     },
   });
   if (exist) {
-    logger.warn(`Invoice already created for subscription ${subscription.id} for next billing cycle: ${exist.id}`);
-    return;
-  }
-
-  // set invoice status if subscription paused
-  let status = 'open';
-  if (subscription.pause_collection) {
-    if (subscription.pause_collection.behavior === 'mark_uncollectible') {
-      status = 'uncollectible';
-    }
-    if (subscription.pause_collection.behavior === 'void') {
-      status = 'void';
-    }
-    if (subscription.pause_collection.behavior === 'keep_as_draft') {
-      status = 'draft';
-    }
+    logger.warn(`Invoice already created for subscription ${subscription.id} for ${reason}: ${exist.id}`);
+    return null;
   }
 
   // expand subscription items
@@ -141,16 +66,14 @@ export const handleSubscription = async (job: SubscriptionJob) => {
 
   // get usage summaries for this billing cycle
   expandedItems = await Promise.all(
-    expandedItems.map(async (x: any) => {
+    expandedItems.filter(filter).map(async (x: any) => {
       // 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 duration = setup.cycle / 1000;
         const rawQuantity = await UsageRecord.getSummary(
           x.id,
-          // FIXME: this causes inconsistency when subscription is paused or billing_cycle_anchor reset
-          setup.period.start - duration,
-          setup.period.end - duration,
+          start - offset,
+          end - offset,
           x.price.recurring?.aggregate_usage
         );
         if (x.price.transform_quantity) {
@@ -169,8 +92,8 @@ export const handleSubscription = async (job: SubscriptionJob) => {
           transformQuantity: x.price.transform_quantity,
           rawQuantity,
           quantity: x.quantity,
-          start: setup.period.start - duration,
-          end: setup.period.end - duration,
+          start: start - offset,
+          end: end - offset,
           usage: x.price.recurring?.aggregate_usage,
         });
 
@@ -182,6 +105,9 @@ export const handleSubscription = async (job: SubscriptionJob) => {
       return x;
     })
   );
+  if (expandedItems.length === 0) {
+    return null;
+  }
 
   const amount = getSubscriptionCycleAmount(expandedItems, currency.id);
 
@@ -193,13 +119,13 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     lineItems: expandedItems,
     props: {
       livemode: subscription.livemode,
-      description: 'Subscription cycle',
+      description: `Subscription ${reason}`,
       statement_descriptor: getStatementDescriptor(expandedItems),
-      period_start: setup.period.start,
-      period_end: setup.period.end,
+      period_start: start,
+      period_end: end,
       auto_advance: true,
       status,
-      billing_reason: 'subscription_cycle',
+      billing_reason: `subscription_${reason}`,
       currency_id: subscription.currency_id,
       total: amount.total,
       payment_settings: subscription.payment_settings,
@@ -208,17 +134,74 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     } as Invoice,
   });
 
-  // schedule invoice job
-  invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
-  logger.info(`Invoice job scheduled for new billing cycle: ${invoice.id}`);
+  return invoice;
+};
+
+const handleSubscriptionBeforeCancel = async (subscription: Subscription) => {
+  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
+  );
 
-  // persist invoice id
-  await subscription.update({
-    latest_invoice_id: invoice.id,
-    current_period_start: setup.period.start,
-    current_period_end: setup.period.end,
-  });
-  logger.info(`Subscription updated for new billing cycle: ${subscription.id}`);
+  if (invoice) {
+    // schedule invoice job
+    invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
+    logger.info(`Invoice job scheduled before cancel: ${invoice.id}`);
+
+    // persist invoice id
+    await subscription.update({ latest_invoice_id: invoice.id });
+    logger.info(`Subscription updated before cancel: ${subscription.id}`);
+  }
+};
+
+const handleSubscriptionWhenActive = async (subscription: Subscription) => {
+  // get setup for next subscription period
+  const previousPeriodEnd =
+    subscription.status === 'trialing' ? subscription.trail_end : subscription.current_period_end;
+  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
+
+  // set invoice status if subscription paused
+  let status = 'open';
+  if (subscription.pause_collection) {
+    if (subscription.pause_collection.behavior === 'mark_uncollectible') {
+      status = 'uncollectible';
+    }
+    if (subscription.pause_collection.behavior === 'void') {
+      status = 'void';
+    }
+    if (subscription.pause_collection.behavior === 'keep_as_draft') {
+      status = 'draft';
+    }
+  }
+
+  const invoice = await handleSubscriptionInvoice(
+    subscription,
+    () => true, // include all items
+    status,
+    'cycle',
+    setup.period.start,
+    setup.period.end,
+    setup.cycle / 1000
+  );
+
+  if (invoice) {
+    // schedule invoice job
+    invoiceQueue.push({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: true } });
+    logger.info(`Invoice job scheduled for new billing cycle: ${invoice.id}`);
+
+    // persist invoice id
+    await subscription.update({
+      latest_invoice_id: invoice.id,
+      current_period_start: setup.period.start,
+      current_period_end: setup.period.end,
+    });
+    logger.info(`Subscription updated for new billing cycle: ${subscription.id}`);
+  }
 
   // schedule next billing cycle if we are not in terminal state
   if (subscription.isActive()) {
@@ -231,6 +214,77 @@ export const handleSubscription = async (job: SubscriptionJob) => {
   }
 };
 
+// generate invoice for subscription periodically
+export const handleSubscription = async (job: SubscriptionJob) => {
+  logger.info('handle subscription', job);
+
+  const subscription = await Subscription.findByPk(job.subscriptionId);
+  if (!subscription) {
+    logger.warn(`Subscription not found: ${job.subscriptionId}`);
+    return;
+  }
+  if (EXPECTED_SUBSCRIPTION_STATUS.includes(subscription.status) === false) {
+    logger.warn(`Subscription status not expected: ${job.subscriptionId}`);
+    return;
+  }
+  const supportAutoCharge = await PaymentMethod.supportAutoCharge(subscription.default_payment_method_id);
+  if (supportAutoCharge === false) {
+    logger.warn(`Subscription does not support auto charge: ${job.subscriptionId}`);
+    return;
+  }
+
+  const now = dayjs().unix();
+
+  // Do we need to cancel the subscription
+  if (subscription.isImmutable() === false) {
+    if (subscription.cancel_at_period_end) {
+      await handleSubscriptionBeforeCancel(subscription);
+      await subscription.update({ status: 'canceled', canceled_at: now });
+      logger.warn(`Subscription canceled on period end: ${job.subscriptionId}`);
+      return;
+    }
+    if (subscription.cancel_at && subscription.cancel_at <= now) {
+      await handleSubscriptionBeforeCancel(subscription);
+      await subscription.update({ status: 'canceled', canceled_at: now });
+      logger.warn(`Subscription canceled on schedule: ${job.subscriptionId}`);
+      return;
+    }
+  }
+
+  // Do we need to resume the subscription
+  if (subscription.pause_collection?.resumes_at && subscription.pause_collection?.resumes_at <= now) {
+    await subscription.update({ status: 'active', pause_collection: undefined });
+    logger.warn(`Subscription resumed as scheduled: ${job.subscriptionId}`);
+  }
+
+  // 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,
+    });
+    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,
+    });
+    return;
+  }
+
+  if (subscription.isActive() === false) {
+    logger.warn(`Subscription not active: ${job.subscriptionId}, so new invoice is skipped`);
+    return;
+  }
+
+  await handleSubscriptionWhenActive(subscription);
+};
+
 export const subscriptionQueue = createQueue<SubscriptionJob>({
   name: 'subscription',
   onJob: handleSubscription,