payment-kit 1.15.16 → 1.15.18

package/api/src/queues/subscription.ts

@@ -1,5 +1,6 @@
 import type { LiteralUnion } from 'type-fest';
 
+import { createEvent } from '@api/libs/audit';
 import { ensurePassportRevoked } from '../integrations/blocklet/passport';
 import { batchHandleStripeSubscriptions } from '../integrations/stripe/resource';
 import { wallet } from '../libs/auth';
@@ -12,6 +13,7 @@ import createQueue from '../libs/queue';
 import { getStatementDescriptor } from '../libs/session';
 import {
   checkRemainingStake,
+  checkUsageReportEmpty,
   getSubscriptionCycleAmount,
   getSubscriptionCycleSetup,
   getSubscriptionStakeAddress,
@@ -111,6 +113,23 @@ const doHandleSubscriptionInvoice = async ({
     { product: true }
   );
 
+  const usageReportStart = usageStart || start - offset;
+  const usageReportEnd = usageEnd || end - offset;
+
+  // check if usage report is empty
+  const usageReportEmpty = await checkUsageReportEmpty(subscription, usageReportStart, usageReportEnd);
+  if (usageReportEmpty) {
+    createEvent('Subscription', 'usage.report.empty', subscription, {
+      usageReportStart,
+      usageReportEnd,
+    }).catch(console.error);
+    logger.info('create usage report empty event', {
+      subscriptionId: subscription.id,
+      usageReportStart,
+      usageReportEnd,
+    });
+  }
+
   // get usage summaries for this billing cycle
   expandedItems = await Promise.all(
     expandedItems.filter(filter).map(async (x: any) => {
@@ -119,8 +138,8 @@ const doHandleSubscriptionInvoice = async ({
       if (x.price.recurring?.usage_type === 'metered') {
         const rawQuantity = await UsageRecord.getSummary({
           id: x.id,
-          start: (usageStart || start) - offset,
-          end: (usageEnd || end) - offset,
+          start: usageReportStart,
+          end: usageReportEnd,
           method: x.price.recurring?.aggregate_usage,
           dryRun: false,
         });
@@ -177,6 +196,8 @@ const doHandleSubscriptionInvoice = async ({
     } as Invoice,
   });
 
+  logger.info('Invoice created for subscription', { invoice: invoice.id, subscription: subscription.id });
+
   return invoice;
 };
 
@@ -401,6 +422,7 @@ const handleStakeSlashAfterCancel = async (subscription: Subscription) => {
     amount: invoice.amount_remaining,
     address,
     txHash,
+    invoice: invoice.id,
   });
 
   await paymentIntent.update({
@@ -645,7 +667,7 @@ export const handleSubscription = async (job: SubscriptionJob) => {
         previousStatus,
       });
 
-      if (previousStatus === 'past_due') {
+      if (previousStatus === 'past_due' && job.action === 'cancel') {
         await handleStakeSlashAfterCancel(subscription);
       }
       return;
@@ -689,21 +711,48 @@ export const subscriptionQueue = createQueue<SubscriptionJob>({
 });
 
 export const startSubscriptionQueue = async () => {
-  const subscriptions = await Subscription.findAll({
-    where: {
-      status: EXPECTED_SUBSCRIPTION_STATUS,
-    },
-  });
+  const lock = getLock('startSubscriptionQueue');
+  if (lock.locked) {
+    return;
+  }
+  logger.info('startSubscriptionQueue');
+  try {
+    await lock.acquire();
+    const subscriptions = await Subscription.findAll({
+      where: {
+        status: EXPECTED_SUBSCRIPTION_STATUS,
+      },
+    });
 
-  subscriptions.forEach(async (x) => {
-    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
-    if (supportAutoCharge === false) {
-      return;
+    const results = await Promise.allSettled(
+      subscriptions.map(async (x) => {
+        const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+        if (supportAutoCharge === false) {
+          return;
+        }
+        if (['past_due', 'paused'].includes(x.status)) {
+          logger.info(`skip add cycle subscription job because status is ${x.status}`, {
+            subscription: x.id,
+            action: 'cycle',
+          });
+          return;
+        }
+        logger.info('add subscription job', { subscription: x.id, action: 'cycle' });
+        await addSubscriptionJob(x, 'cycle', process.env.PAYMENT_RELOAD_SUBSCRIPTION_JOBS === '1');
+      })
+    );
+
+    const failed = results.filter((r) => r.status === 'rejected').length;
+    if (failed > 0) {
+      logger.warn(`Failed to process ${failed} subscriptions in startSubscriptionQueue`);
     }
-    await addSubscriptionJob(x, 'cycle', process.env.PAYMENT_RELOAD_SUBSCRIPTION_JOBS === '1');
-  });
 
-  await batchHandleStripeSubscriptions();
+    await batchHandleStripeSubscriptions();
+  } catch (error) {
+    logger.error('Error in startSubscriptionQueue:', error);
+  } finally {
+    lock.release();
+  }
 };
 
 export const slashStakeQueue = createQueue({

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

@@ -136,6 +136,23 @@ export async function validateInventory(line_items: LineItem[], includePendingQu
   await Promise.all(checks);
 }
 
+const SubscriptionDataSchema = Joi.object({
+  service_actions: Joi.array()
+    .items(
+      Joi.object({
+        name: Joi.string().optional(),
+        color: Joi.string().allow('primary', 'secondary', 'success', 'error', 'warning').optional(),
+        variant: Joi.string().allow('text', 'contained', 'outlined').optional(),
+        text: Joi.object().required(),
+        link: Joi.string().uri().required(),
+        type: Joi.string().allow('notification', 'custom').optional(),
+        triggerEvents: Joi.array().items(Joi.string()).optional(),
+      })
+    )
+    .min(0)
+    .optional(),
+}).unknown(true);
+
 export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = true) => {
   const raw: Partial<CheckoutSession> = Object.assign(
     {
@@ -161,6 +178,7 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
         billing_threshold_amount: 0,
         min_stake_amount: 0,
         trial_end: 0,
+        service_actions: [],
       },
       payment_intent_data: {},
       submit_type: 'pay',
@@ -193,6 +211,13 @@ export const formatCheckoutSession = async (payload: any, throwOnEmptyItems = tr
     raw.subscription_data.trial_period_days = Number(raw.subscription_data.trial_period_days);
   }
 
+  if (raw.subscription_data?.service_actions) {
+    const { error } = SubscriptionDataSchema.validate(raw.subscription_data);
+    if (error) {
+      throw new Error('Invalid service actions for checkout session');
+    }
+  }
+
   if (!raw.expires_at) {
     raw.expires_at = dayjs().unix() + CHECKOUT_SESSION_TTL;
   }
@@ -869,6 +894,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
             checkoutSession.subscription_data?.days_until_cancel ?? checkoutSession.metadata?.days_until_cancel,
           recovered_from: recoveredFrom?.id,
           metadata: omit(checkoutSession.metadata || {}, ['days_until_due', 'days_until_cancel']),
+          service_actions: checkoutSession.subscription_data?.service_actions || [],
         });
 
         logger.info('subscription created on checkout session submit', {

package/api/src/routes/invoices.ts

@@ -20,6 +20,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
+import { getSubscriptionStakeAmountSetup } from '../libs/subscription';
 
 const router = Router();
 const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -131,44 +132,23 @@ router.get('/', authMine, async (req, res) => {
         if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
           const method = await PaymentMethod.findOne({ where: { type: 'arcblock', livemode: subscription.livemode } });
           if (method) {
-            const client = method.getOcapClient();
             const { address } = subscription.payment_details.arcblock.staking;
-            const { state } = await client.getStakeState({ address });
             const firstInvoice = await Invoice.findOne({
               where: { subscription_id: subscription.id },
               order: [['created_at', 'ASC']],
+              include: [{ model: PaymentCurrency, as: 'paymentCurrency' }],
             });
             const last = query.o === 'asc' ? list?.[list.length - 1] : list?.[0];
-            if (state && firstInvoice) {
-              const data = JSON.parse(state.data?.value || '{}');
+            if (subscription.payment_details.arcblock.staking.tx_hash && firstInvoice) {
               const customer = await Customer.findByPk(firstInvoice.customer_id);
-              const currency = await PaymentCurrency.findOne({
-                where: { payment_method_id: method.id, is_base_currency: true },
-              });
-
-              let stakeAmount = data[subscription.id];
-              if (state.nonce) {
-                stakeAmount = state.tokens?.find((x: any) => x.address === currency?.contract)?.value;
-                // stakeAmount should not be zero if nonce exist
-                if (!Number(stakeAmount)) {
-                  if (subscription.cancelation_details?.return_stake) {
-                    const refund = await Refund.findOne({
-                      where: { subscription_id: subscription.id, status: 'succeeded', type: 'stake_return' },
-                    });
-                    if (refund) {
-                      stakeAmount = refund.amount;
-                    }
-                  }
-                  if (subscription.cancelation_details?.slash_stake) {
-                    const invoice = await Invoice.findOne({
-                      where: { subscription_id: subscription.id, status: 'paid', billing_reason: 'slash_stake' },
-                    });
-                    if (invoice) {
-                      stakeAmount = invoice.total;
-                    }
-                  }
-                }
-              }
+              const currency =
+                // @ts-ignore
+                firstInvoice?.paymentCurrency ||
+                (await PaymentCurrency.findOne({
+                  where: { payment_method_id: method.id, is_base_currency: true },
+                }));
+              const stakeAmountResult = await getSubscriptionStakeAmountSetup(subscription, method);
+              const stakeAmount = stakeAmountResult?.[currency?.contract] || '0';
 
               list.push({
                 id: address as string,

package/api/src/routes/subscriptions.ts

@@ -7,6 +7,7 @@ import pick from 'lodash/pick';
 import uniq from 'lodash/uniq';
 
 import { literal, OrderItem } from 'sequelize';
+import { createEvent } from '../libs/audit';
 import { ensureStripeCustomer, ensureStripePrice, ensureStripeSubscription } from '../integrations/stripe/resource';
 import { createListParamSchema, getWhereFromKvQuery, getWhereFromQuery, MetadataSchema } from '../libs/api';
 import dayjs from '../libs/dayjs';
@@ -692,11 +693,13 @@ const updateSchema = Joi.object<{
   service_actions: Joi.array()
     .items(
       Joi.object({
-        name: Joi.string().required(),
-        color: Joi.string().allow('primary', 'secondary', 'success', 'error', 'warning').required(),
-        variant: Joi.string().allow('text', 'contained', 'outlined').required(),
+        name: Joi.string().optional(),
+        color: Joi.string().allow('primary', 'secondary', 'success', 'error', 'warning').optional(),
+        variant: Joi.string().allow('text', 'contained', 'outlined').optional(),
         text: Joi.object().required(),
         link: Joi.string().uri().required(),
+        type: Joi.string().allow('notification', 'custom').optional(),
+        triggerEvents: Joi.array().items(Joi.string()).optional(),
       })
     )
     .optional(),
@@ -851,10 +854,15 @@ router.put('/:id', authPortal, async (req, res) => {
         // update subscription period settings
         // HINT: if we are adding new items, we need to reset the anchor to now
         const setup = getSubscriptionCreateSetup(newItems, paymentCurrency.id, 0);
+        // Check if the subscription is currently in trial
+        const isInTrial =
+          subscription.status === 'trialing' && subscription.trial_end && subscription.trial_end > dayjs().unix();
         if (newItems.some((x) => x.price.type === 'recurring' && addedItems.find((y) => y.price_id === x.price_id))) {
           updates.pending_invoice_item_interval = setup.recurring;
-          updates.current_period_start = setup.period.start;
-          updates.current_period_end = setup.period.end;
+          if (!isInTrial) {
+            updates.current_period_start = setup.period.start;
+            updates.current_period_end = setup.period.end;
+          }
           updates.billing_cycle_anchor = setup.cycle.anchor;
           logger.info('subscription updates on reset anchor', { subscription: req.params.id, updates });
         }
@@ -869,12 +877,30 @@ router.put('/:id', authPortal, async (req, res) => {
           }
 
           // 1. create proration
-          const { lastInvoice, due, newCredit, appliedCredit, prorations } = await createProration(
+          const { lastInvoice, due, newCredit, appliedCredit, prorations, total } = await createProration(
             subscription,
             setup,
             dayjs().unix()
           );
 
+          if ((total === '0' && isInTrial) || newCredit !== '0') {
+            // 0 amount or new credit means no need to create invoice
+            await subscription.update(updates);
+            await finalizeSubscriptionUpdate({
+              subscription,
+              customer,
+              invoice: null,
+              paymentCurrency,
+              appliedCredit,
+              newCredit,
+              addedItems,
+              deletedItems,
+              updatedItems,
+              updates,
+            });
+            await createEvent('Subscription', 'customer.subscription.upgraded', subscription).catch(console.error);
+            return res.json({ ...subscription.toJSON(), connectAction });
+          }
           // 2. create new invoice: amount according to new subscription items
           // 3. create new invoice items: amount according to new subscription items
           const result = await ensureInvoiceAndItems({
@@ -894,7 +920,7 @@ router.put('/:id', authPortal, async (req, res) => {
               period_end: setup.period.end,
               auto_advance: true,
               billing_reason: 'subscription_update',
-              total: setup.amount.setup,
+              total,
               currency_id: paymentCurrency.id,
               default_payment_method_id: subscription.default_payment_method_id,
               custom_fields: lastInvoice.custom_fields || [],
@@ -977,6 +1003,16 @@ router.put('/:id', authPortal, async (req, res) => {
               invoice: invoice.id,
             });
           } else {
+            await subscription.update({
+              pending_update: {
+                updates,
+                appliedCredit,
+                newCredit,
+                addedItems,
+                deletedItems,
+                updatedItems,
+              },
+            });
             await invoiceQueue.pushAndWait({
               id: invoice.id,
               job: { invoiceId: invoice.id, retryOnError: false, waitForPayment: true },

package/api/src/store/models/checkout-session.ts

@@ -24,6 +24,7 @@ import type {
   NftMintSettings,
   PaymentDetails,
   PaymentIntentData,
+  ServiceAction,
   SubscriptionData,
 } from './types';
 
@@ -158,6 +159,7 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
 
   // When creating a subscription, the specified configuration data will be used.
   declare subscription_data?: SubscriptionData & {
+    service_actions?: ServiceAction[];
     billing_cycle_anchor?: number;
     metadata?: Record<string, any>;
     proration_behavior?: LiteralUnion<'create_prorations' | 'none', string>;

package/api/src/store/models/job.ts

@@ -70,6 +70,10 @@ export class Job extends Model<InferAttributes<Job>, InferCreationAttributes<Job
   public static associate() {
     // Do nothing
   }
+
+  public static isInitialized(): boolean {
+    return this.sequelize !== undefined;
+  }
 }
 
 export type TJob = InferAttributes<Job>;

package/api/src/store/models/types.ts

@@ -44,10 +44,26 @@ export type PriceCurrency = {
   custom_unit_amount: CustomUnitAmount | null;
 };
 
+// 这里为triggerEvents的事件类型
+type NotificationActionEvents =
+  | 'customer.subscription.started'
+  | 'customer.subscription.renewed'
+  | 'customer.subscription.renew_failed'
+  | 'refund.succeeded'
+  | 'subscription.stake.slash.succeeded'
+  | 'customer.subscription.trial_will_end'
+  | 'customer.subscription.trial_start'
+  | 'customer.subscription.upgraded'
+  | 'customer.subscription.will_renew'
+  | 'customer.subscription.will_canceled'
+  | 'customer.subscription.deleted';
+
 export type ServiceAction = {
-  name: string;
-  color: string;
-  variant: string;
+  type?: LiteralUnion<'notification' | 'custom', string>;
+  triggerEvents?: NotificationActionEvents[];
+  name?: string;
+  color?: LiteralUnion<'primary' | 'secondary' | 'success' | 'error' | 'warning', string>;
+  variant?: LiteralUnion<'text' | 'contained' | 'outlined', string>;
   text: { [key: string]: string };
   link: string;
 };
@@ -640,7 +656,9 @@ export type EventType = LiteralUnion<
   | 'topup.succeeded'
   | 'transfer.created'
   | 'transfer.reversed'
-  | 'transfer.updated',
+  | 'transfer.updated'
+  | 'billing.discrepancy'
+  | 'usage.report.empty',
   string
 >;
 

package/api/src/store/models/usage-record.ts

@@ -100,17 +100,21 @@ export class UsageRecord extends Model<InferAttributes<UsageRecord>, InferCreati
     end,
     method,
     dryRun,
+    billed = false,
+    searchBilled = true,
   }: {
     id: string;
     start: number;
     end: number;
     method: LiteralUnion<'sum' | 'last_during_period' | 'max' | 'last_ever', string>;
     dryRun: boolean;
+    billed?: boolean;
+    searchBilled?: boolean;
   }): Promise<number> {
     const query = {
       where: {
         subscription_item_id: id,
-        billed: false,
+        ...(searchBilled ? { billed } : {}),
         timestamp: {
           [Op.gt]: start,
           [Op.lte]: end,

package/api/tests/libs/subscription.spec.ts

@@ -9,7 +9,10 @@ import {
   getSubscriptionStakeSetup,
   getSubscriptionTrialSetup,
   shouldCancelSubscription,
+  getSubscriptionStakeAmountSetup,
+  checkUsageReportEmpty,
 } from '../../src/libs/subscription';
+import { PaymentMethod, Subscription, SubscriptionItem, UsageRecord, Price } from '../../src/store/models';
 
 describe('getDueUnit', () => {
   it('should return 60 for recurring interval of "hour"', () => {
@@ -411,3 +414,154 @@ describe('getSubscriptionTrialSetup', () => {
     expect(result).toEqual({ trialInDays: 0, trialEnd: 0 });
   });
 });
+
+describe('getSubscriptionStakeAmountSetup', () => {
+  let mockSubscription: Subscription;
+  let mockPaymentMethod: PaymentMethod;
+  let mockGetOcapClient: jest.Mock;
+  let mockGetTx: jest.Mock;
+
+  beforeEach(() => {
+    mockSubscription = {
+      payment_details: {
+        arcblock: {
+          staking: {
+            tx_hash: 'mock_tx_hash',
+          },
+        },
+      },
+    } as Subscription;
+
+    mockGetTx = jest.fn();
+    mockGetOcapClient = jest.fn().mockReturnValue({
+      getTx: mockGetTx,
+    });
+
+    // @ts-ignore
+    mockPaymentMethod = {
+      type: 'arcblock',
+      getOcapClient: mockGetOcapClient,
+    };
+  });
+
+  it('should return null if payment method is not arcblock', async () => {
+    mockPaymentMethod.type = 'other';
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if tx_hash is missing', async () => {
+    // @ts-ignore
+    mockSubscription.payment_details.arcblock.staking.tx_hash = undefined;
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if getTx info is null', async () => {
+    mockGetTx.mockResolvedValue({ info: null });
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should return null if inputs are empty', async () => {
+    mockGetTx.mockResolvedValue({
+      info: {
+        tx: {
+          itxJson: {
+            inputs: [],
+          },
+        },
+      },
+    });
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toBeNull();
+  });
+
+  it('should calculate stake amount correctly', async () => {
+    mockGetTx.mockResolvedValue({
+      info: {
+        tx: {
+          itxJson: {
+            inputs: [
+              {
+                tokens: [
+                  { address: 'addr1', value: '100' },
+                  { address: 'addr2', value: '200' },
+                ],
+              },
+              {
+                tokens: [
+                  { address: 'addr1', value: '300' },
+                  { address: 'addr3', value: '400' },
+                ],
+              },
+            ],
+          },
+        },
+      },
+    });
+
+    const result = await getSubscriptionStakeAmountSetup(mockSubscription, mockPaymentMethod);
+    expect(result).toEqual({
+      addr1: '400',
+      addr2: '200',
+      addr3: '400',
+    });
+  });
+});
+
+// 模拟的依赖项
+const mockSubscriptionItems = [
+  { id: 'item_1', price_id: 'price_1', quantity: 1 },
+  { id: 'item_2', price_id: 'price_2', quantity: 1 },
+];
+
+const mockExpandedItems = [
+  { id: 'item_1', price: { recurring: { usage_type: 'metered' } } },
+  { id: 'item_2', price: { recurring: { usage_type: 'metered' } } },
+];
+
+const mockUsageRecordsEmpty: any[] = [];
+const mockUsageRecordsWithData = [{ id: 'usage_1' }];
+
+describe('checkUsageReportEmpty', () => {
+  const subscription = { id: 'sub_123' };
+  const usageReportStart = 1622505600;
+  const usageReportEnd = 1622592000;
+
+  beforeEach(() => {
+    // Reset any state if necessary
+  });
+
+  it('should return true if there are no usage records', async () => {
+    // Mock the behavior of the functions directly
+    jest.spyOn(SubscriptionItem, 'findAll').mockResolvedValue(mockSubscriptionItems as any);
+    jest.spyOn(Price, 'expand').mockResolvedValue(mockExpandedItems as any);
+    jest.spyOn(UsageRecord, 'findAll').mockResolvedValue(mockUsageRecordsEmpty);
+
+    const result = await checkUsageReportEmpty(subscription as any, usageReportStart, usageReportEnd);
+    expect(result).toBe(true);
+  });
+
+  it('should return false if there are usage records', async () => {
+    jest.spyOn(SubscriptionItem, 'findAll').mockResolvedValue(mockSubscriptionItems as any);
+    jest.spyOn(Price, 'expand').mockResolvedValue(mockExpandedItems as any);
+    jest.spyOn(UsageRecord, 'findAll').mockResolvedValue(mockUsageRecordsWithData as any);
+
+    const result = await checkUsageReportEmpty(subscription as any, usageReportStart, usageReportEnd);
+    expect(result).toBe(false);
+  });
+
+  it('should handle multiple metered items', async () => {
+    jest.spyOn(SubscriptionItem, 'findAll').mockResolvedValue(mockSubscriptionItems as any);
+    jest.spyOn(Price, 'expand').mockResolvedValue(mockExpandedItems as any);
+
+    jest
+      .spyOn(UsageRecord, 'findAll')
+      .mockResolvedValueOnce(mockUsageRecordsEmpty)
+      .mockResolvedValueOnce(mockUsageRecordsWithData as any);
+
+    const result = await checkUsageReportEmpty(subscription as any, usageReportStart, usageReportEnd);
+    expect(result).toBe(false);
+  });
+});