payment-kit 1.15.20 → 1.15.22

package/api/src/crons/base.ts

@@ -34,13 +34,19 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
     const subscriptions = await this.getSubscriptions();
     logger.info(`${name}.run.${subscriptions.length}`, subscriptions.length);
 
-    const subscriptionForWillRenew = this.getSubscriptionsForWillRenew(subscriptions);
+    const scheduleSubscriptions = this.getScheduleSubscriptions(subscriptions);
 
-    await this.addTaskToQueue(subscriptionForWillRenew);
+    await this.addTaskToQueue(scheduleSubscriptions);
 
     logger.info(`${name}.run end`);
   }
 
+  async reScheduleSubscriptionTasks(subscriptions: Subscription[]): Promise<void> {
+    await this.deleteScheduleSubscriptionJobs(subscriptions);
+    const scheduleSubscriptions = this.getScheduleSubscriptions(subscriptions);
+    await this.addTaskToQueue(scheduleSubscriptions);
+  }
+
   static readonly DIFFS: Diff[] = [
     {
       value: 1,
@@ -67,6 +73,8 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
       unit: 'm',
     },
   ];
+
+  abstract getEndTime(subscription: Subscription): number;
   /**
    * @see https://github.com/blocklet/payment-kit/issues/236#issuecomment-1824129965
    * @description
@@ -74,13 +82,13 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
    * @return {*}  {SubscriptionForWillRenew[]}
    * @memberof SubscriptionWillRenewSchedule
    */
-  getSubscriptionsForWillRenew(subscriptions: Subscription[]): BaseSubscriptionScheduleNotificationSubscription[] {
+  getScheduleSubscriptions(subscriptions: Subscription[]): BaseSubscriptionScheduleNotificationSubscription[] {
     return subscriptions.map((subscription: Subscription): BaseSubscriptionScheduleNotificationSubscription => {
       const s: BaseSubscriptionScheduleNotificationSubscription = clone(
         subscription
       ) as BaseSubscriptionScheduleNotificationSubscription;
       const currentPeriodStart: number = s.current_period_start * 1000;
-      const currentPeriodEnd: number = s.current_period_end * 1000;
+      const currentPeriodEnd: number = this.getEndTime(s);
 
       if (
         dayjs(currentPeriodEnd).diff(this.start, 'M') >= 1 &&
@@ -151,13 +159,26 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
 
   async addTaskToQueue(subscriptions: BaseSubscriptionScheduleNotificationSubscription[]): Promise<void> {
     const tasks: Task<Options>[] = [];
+    const deleteTasks = [];
     for (const subscription of subscriptions) {
       for (const diff of subscription.diffs) {
-        const task: Task<Options> = this.getTask({ subscription, diff });
-        tasks.push(task);
+        try {
+          const task: Task<Options> = this.getTask({ subscription, diff });
+          tasks.push(task);
+        } catch (error) {
+          logger.error('getTask error', { error, subscriptionId: subscription.id, diff });
+          deleteTasks.push(() => this.deleteScheduleSubscriptionJobs([subscription]));
+        }
       }
     }
 
+    await pAll(
+      deleteTasks.map((task) => () => task()),
+      {
+        concurrency: notificationCronConcurrency,
+        stopOnError: false,
+      }
+    );
     await pAll(
       tasks.map((x) => {
         return async () => {
@@ -170,7 +191,48 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
           notificationQueue.push(x);
         };
       }),
-      { concurrency: notificationCronConcurrency }
+      {
+        concurrency: notificationCronConcurrency,
+        stopOnError: false,
+      }
     );
   }
+
+  async deleteScheduleSubscriptionJobs(subscriptions: Subscription[]): Promise<void> {
+    const jobsToDelete = await Promise.all(
+      subscriptions.flatMap((subscription) =>
+        BaseSubscriptionScheduleNotification.DIFFS.map(async (diff) => {
+          const jobId = `${subscription.id}.${this.eventType}.${diff.value}.${diff.unit}`;
+          const job = await notificationQueue.get(jobId);
+          return job ? { jobId, subscriptionId: subscription.id } : null;
+        })
+      )
+    );
+
+    const existingJobs = jobsToDelete.filter((x): x is { jobId: string; subscriptionId: string } => x !== null);
+
+    const deletePromises = existingJobs.map(
+      ({ jobId, subscriptionId }: { jobId: string; subscriptionId: string }) =>
+        async () => {
+          try {
+            const deleted = await notificationQueue.delete(jobId);
+            if (deleted) {
+              logger.info('Deleted subscription job', { jobId, subscriptionId, eventType: this.eventType });
+            }
+          } catch (error) {
+            logger.error('Failed to delete subscription job', {
+              jobId,
+              subscriptionId,
+              eventType: this.eventType,
+              error: error instanceof Error ? error.message : String(error),
+            });
+          }
+        }
+    );
+
+    await pAll(deletePromises, {
+      concurrency: notificationCronConcurrency,
+      stopOnError: false,
+    });
+  }
 }

package/api/src/crons/subscription-trial-will-end.ts

@@ -17,7 +17,7 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
         current_period_start: {
           [Op.lte]: this.start / 1000,
         },
-        current_period_end: {
+        trial_end: {
           [Op.lt]: this.end / 1000,
         },
         trial_start: {
@@ -25,7 +25,7 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
         },
         status: 'trialing',
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'trial_end'],
       raw: true,
     });
 
@@ -40,6 +40,19 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
     diff: Diff;
   }): Task<SubscriptionTrialWillEndEmailTemplateOptions> {
     const type = this.eventType;
+    if (subscription.status !== 'trialing') {
+      throw new Error(`Subscription(${subscription.id}) is not trialing, no need to send notification`);
+    }
+
+    const trialEnd = this.getEndTime(subscription);
+    if (!subscription.trial_end) {
+      throw new Error(`Subscription(${subscription.id}) has no trial_end, no need to send notification`);
+    }
+
+    if (trialEnd <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already expired, no need to send notification`);
+    }
+
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -51,9 +64,11 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
           required: !!diff.required,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(trialEnd).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return subscription.trial_end! * 1000;
+  }
 }

package/api/src/crons/subscription-will-canceled.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import dayjs from 'dayjs';
 
+import { Op } from 'sequelize';
 import type { SubscriptionWillCanceledEmailTemplateOptions } from '../libs/notification/template/subscription-will-canceled';
 import { Subscription } from '../store/models';
 import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
@@ -12,14 +13,20 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
   async getSubscriptions(): Promise<Subscription[]> {
     const subscriptions = await Subscription.findAll({
       where: {
-        status: 'past_due',
+        status: ['active', 'past_due'],
+        [Op.or]: [
+          { cancel_at: { [Op.gt]: this.start } },
+          { cancel_at_period_end: true, current_period_end: { [Op.gt]: this.start } },
+        ],
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'cancel_at', 'status'],
       raw: true,
     });
 
     subscriptions.forEach((subscription) => {
-      subscription.current_period_end = subscription.cancel_at!;
+      if (subscription.cancel_at) {
+        subscription.current_period_end = subscription.cancel_at;
+      }
     });
 
     return subscriptions;
@@ -33,6 +40,13 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
     diff: Diff;
   }): Task<SubscriptionWillCanceledEmailTemplateOptions> {
     const type = this.eventType;
+    const cancelAt = this.getEndTime(subscription);
+    if (!cancelAt) {
+      throw new Error(`Subscription(${subscription.id}) has no cancel_at, no need to send notification`);
+    }
+    if (cancelAt <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already canceled, no need to send notification`);
+    }
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -44,9 +58,11 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
           required: true,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(cancelAt).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return (subscription.cancel_at || subscription.current_period_end) * 1000;
+  }
 }

package/api/src/crons/subscription-will-renew.ts

@@ -21,7 +21,7 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
         },
         status: 'active',
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'status'],
       raw: true,
     });
 
@@ -36,6 +36,13 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
     diff: Diff;
   }): Task<SubscriptionWillRenewEmailTemplateOptions> {
     const type = this.eventType;
+    const periodEnd = this.getEndTime(subscription);
+    if (periodEnd <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already expired, no need to send notification`);
+    }
+    if (subscription.status !== 'active') {
+      throw new Error(`Subscription(${subscription.id}) is not active, no need to send notification`);
+    }
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -47,9 +54,11 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
           required: !!diff.required,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(periodEnd).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return subscription.current_period_end * 1000;
+  }
 }

package/api/src/index.ts

@@ -19,7 +19,7 @@ import { initResourceHandler } from './integrations/blocklet/resource';
 import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { handlers } from './libs/auth';
 import logger, { accessLogStream } from './libs/logger';
-import { ensureI18n } from './libs/middleware';
+import { contextMiddleware, ensureI18n } from './libs/middleware';
 import { initEventBroadcast } from './libs/ws';
 import { startCheckoutSessionQueue } from './queues/checkout-session';
 import { startEventQueue } from './queues/event';
@@ -33,6 +33,7 @@ import changePaymentHandlers from './routes/connect/change-payment';
 import changePlanHandlers from './routes/connect/change-plan';
 import collectHandlers from './routes/connect/collect';
 import collectBatchHandlers from './routes/connect/collect-batch';
+import rechargeHandlers from './routes/connect/recharge';
 import payHandlers from './routes/connect/pay';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
@@ -69,6 +70,7 @@ handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));
 handlers.attach(Object.assign({ app: router }, changePaymentHandlers));
 handlers.attach(Object.assign({ app: router }, changePlanHandlers));
+handlers.attach(Object.assign({ app: router }, rechargeHandlers));
 
 router.use('/api', routes);
 
@@ -91,6 +93,7 @@ if (isProduction) {
   });
 }
 
+app.use(contextMiddleware);
 app.use(router);
 
 if (isProduction) {

package/api/src/integrations/arcblock/stake.ts

@@ -261,3 +261,30 @@ export async function getTokenSummaryByDid(
 
   return results;
 }
+
+export async function getTokenByAddress(
+  address: string,
+  paymentMethod: PaymentMethod,
+  paymentCurrency: PaymentCurrency
+): Promise<string | undefined> {
+  if (paymentMethod.type === 'arcblock') {
+    const client = paymentMethod.getOcapClient();
+    const { tokens } = await client.getAccountTokens({ address });
+    return tokens.find((t: any) => t.address === paymentCurrency.contract)?.balance;
+  }
+  if (paymentMethod.type === 'ethereum') {
+    const client = paymentMethod.getEvmClient();
+    if (paymentCurrency.contract) {
+      const token = await fetchErc20Balance(client, paymentCurrency.contract, address);
+      return token;
+    }
+    const token = await fetchEtherBalance(client, address);
+    return token;
+  }
+  logger.info(`unsupported payment method type: ${paymentMethod.type}`, {
+    paymentCurrencyId: paymentCurrency.id,
+    paymentMethodId: paymentMethod.id,
+    address,
+  });
+  return '0';
+}

package/api/src/libs/audit.ts

@@ -4,6 +4,7 @@ import type { LiteralUnion } from 'type-fest';
 import type { EventType } from '../store/models';
 import { Event } from '../store/models/event';
 import { events } from './event';
+import { context } from './context';
 
 const API_VERSION = '2023-09-05';
 
@@ -15,7 +16,6 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
     data.previous_attributes = pick(model._previousDataValues, options.fields);
   }
   // console.log('createEvent', scope, type, data, options);
-
   const event = await Event.create({
     type,
     api_version: API_VERSION,
@@ -27,6 +27,7 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue
@@ -69,6 +70,7 @@ export async function createStatusEvent(
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue
@@ -107,6 +109,7 @@ export async function createCustomEvent(
       // FIXME:
       id: '',
       idempotency_key: '',
+      requested_by: options.requestedBy || context.getRequestedBy() || 'system',
     },
     metadata: {},
     pending_webhooks: 99, // force all events goto the event queue

package/api/src/libs/context.ts

@@ -0,0 +1,48 @@
+import { AsyncLocalStorage, AsyncResource } from 'async_hooks';
+
+interface RequestContext {
+  requestedBy?: string;
+  requestId?: string;
+}
+
+class RequestContextManager {
+  private storage = new AsyncLocalStorage<RequestContext>();
+  private contexts = new Map<string, RequestContext>();
+
+  getContext(requestId?: string): RequestContext {
+    if (requestId && this.contexts.has(requestId)) {
+      return this.contexts.get(requestId)!;
+    }
+    return this.storage.getStore() || {};
+  }
+
+  getRequestedBy(requestId?: string): string | undefined {
+    return this.getContext(requestId).requestedBy;
+  }
+
+  run<T>(context: RequestContext, fn: () => Promise<T> | T): Promise<T> {
+    const requestId = context.requestId || `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    this.contexts.set(requestId, {
+      ...context,
+      requestId,
+    });
+
+    return new Promise((resolve, reject) => {
+      this.storage.run({ ...context, requestId }, async () => {
+        const resource = new AsyncResource('RequestContext');
+        try {
+          const result = await resource.runInAsyncScope(fn);
+          resolve(result);
+        } catch (err) {
+          reject(err);
+        } finally {
+          // 清理上下文
+          this.contexts.delete(requestId);
+        }
+      });
+    });
+  }
+}
+
+export const context = new RequestContextManager();

package/api/src/libs/invoice.ts

@@ -71,7 +71,7 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
     });
     return oneTimePaymentInfo;
   } catch (err) {
-    console.error(err);
+    console.error(`Error in getOneTimeProductInfo for invoice ${invoiceId}:`, err);
     return [];
   }
 }
@@ -140,7 +140,7 @@ export async function getInvoiceShouldPayTotal(invoice: Invoice) {
     const amount = getSubscriptionCycleAmount(expandedItems, subscription.currency_id);
     return amount?.total || invoice.total;
   } catch (err) {
-    console.error(err);
+    console.error(`Error in getInvoiceShouldPayTotal for invoice ${invoice.id}:`, err);
     return invoice.total;
   }
 }

package/api/src/libs/middleware.ts

@@ -1,7 +1,8 @@
 /* eslint-disable import/prefer-default-export */
 import type { NextFunction, Request, Response } from 'express';
-
+import { verify } from '@blocklet/sdk/lib/util/verify-sign';
 import { translate } from '../locales';
+import { context } from './context';
 
 export function ensureI18n() {
   return (req: Request, _: Response, next: NextFunction) => {
@@ -10,3 +11,40 @@ export function ensureI18n() {
     next();
   };
 }
+
+export function contextMiddleware(req: Request, _res: Response, next: NextFunction) {
+  const requestId =
+    (req.headers['x-request-id'] as string) || `req_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  let requestedBy = 'system';
+
+  // Check component signature
+  const sig = req.get('x-component-sig');
+  const componentDid = req.get('x-component-did');
+  if (sig && componentDid) {
+    const data = typeof req.body === 'undefined' ? {} : req.body;
+    const verified = verify(data, sig);
+    if (verified) {
+      requestedBy = componentDid;
+    }
+  }
+
+  // Check user DID from headers
+  if (req.headers['x-user-did']) {
+    requestedBy = req.headers['x-user-did'] as string;
+  }
+
+  // Check authenticated user
+  if (req.user?.did) {
+    requestedBy = req.user.did;
+  }
+
+  return context.run(
+    {
+      requestId,
+      requestedBy,
+    },
+    async () => {
+      await next();
+    }
+  );
+}

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

@@ -122,6 +122,10 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       cancellationReason = translate('notification.subscriptionCanceled.paymentFailed', locale);
     }
 
+    if (subscription.cancelation_details?.reason === 'stake_revoked') {
+      cancellationReason = translate('notification.subscriptionCanceled.stakeRevoked', locale);
+    }
+
     // @ts-expect-error
     const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
     const viewSubscriptionLink = getCustomerSubscriptionPageUrl({

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

@@ -11,7 +11,7 @@ import { Customer, PaymentMethod, Subscription, PaymentCurrency } from '../../..
 import { PaymentDetail, getPaymentAmountForCycleSubscription } from '../../payment';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
-import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import { formatTime, getPrettyMsI18nLocale, getSimplifyDuration } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 import dayjs from '../../dayjs';
 import { getSubscriptionNotificationCustomActions } from '../../util';
@@ -27,7 +27,7 @@ interface SubscriptionTrialWilEndEmailTemplateContext {
   locale: string;
   productName: string;
   at: string;
-  willRenewDuration: string;
+  willEndDuration: string;
   paymentDetail: PaymentDetail;
 
   userDid: string;
@@ -79,10 +79,13 @@ export class SubscriptionTrialWilEndEmailTemplate
     const userDid = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
+    if (!subscription.trial_end) {
+      throw new Error(`Subscription has no trial end: ${subscription.id}`);
+    }
+
     const at: string = formatTime((subscription.trial_end as number) * 1000);
-    const willRenewDuration: string =
-      locale === 'en' ? this.getWillRenewDuration(locale) : this.getWillRenewDuration(locale).split(' ').join('');
 
+    const willEndDuration: string = getSimplifyDuration((subscription.trial_end! - dayjs().unix()) * 1000, locale);
     // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
 
     const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
@@ -117,7 +120,7 @@ export class SubscriptionTrialWilEndEmailTemplate
       locale,
       productName,
       at,
-      willRenewDuration,
+      willEndDuration,
       paymentDetail,
 
       userDid,
@@ -132,37 +135,12 @@ export class SubscriptionTrialWilEndEmailTemplate
     };
   }
 
-  getWillRenewDuration(locale: string): string {
-    if (this.options.willRenewUnit === 'M') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.months', locale)}`;
-      }
-
-      return `${this.options.willRenewValue} ${translate('notification.common.month', locale)}`;
-    }
-    if (this.options.willRenewUnit === 'd') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.days', locale)}`;
-      }
-      return `${this.options.willRenewValue} ${translate('notification.common.day', locale)}`;
-    }
-
-    if (this.options.willRenewUnit === 'm') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.minutes', locale)}`;
-      }
-      return `${this.options.willRenewValue} ${translate('notification.common.minute', locale)}`;
-    }
-
-    return `${this.options.willRenewValue} ${this.options.willRenewUnit}`;
-  }
-
   async getTemplate(): Promise<BaseEmailTemplateType | null> {
     const {
       locale,
       productName,
       at,
-      willRenewDuration,
+      willEndDuration,
       paymentDetail,
 
       userDid,
@@ -191,19 +169,19 @@ export class SubscriptionTrialWilEndEmailTemplate
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionTrialWillEnd.title', locale, {
         productName,
-        willRenewDuration,
+        willEndDuration,
       })}`,
       body:
         canPay || isStripe
           ? `${translate('notification.subscriptionTrialWillEnd.body', locale, {
               at,
               productName,
-              willRenewDuration,
+              willEndDuration,
             })}`
           : `${translate('notification.subscriptionTrialWillEnd.unableToPayBody', locale, {
               at,
               productName,
-              willRenewDuration,
+              willEndDuration,
               balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
               price: `${paymentDetail.price} ${paymentDetail.symbol}`,
             })}`,