payment-kit 1.13.69 → 1.13.71

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

@@ -80,7 +80,8 @@ export class SubscriptionSucceededEmailTemplate
         ]);
 
         return Boolean(
-          ['minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string) && invoice?.payment_intent_id
+          ['disabled', 'minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string) &&
+            invoice?.payment_intent_id
         );
       },
       { timeout: 1000 * 10, interval: 1000 }

package/api/src/libs/payment.ts

@@ -66,7 +66,7 @@ export async function isDelegationSufficientForPayment(args: {
     }
 
     // check token limits
-    if (grant.limit) {
+    if (grant.limit && Array.isArray(grant.limit.tokens) && grant.limit.tokens.length > 0) {
       const tokenLimit = grant.limit.tokens.find((x: any) => x.address === tokenAddress);
       if (!tokenLimit) {
         return { sufficient: false, reason: 'NO_TOKEN_PERMISSION' };

package/api/src/libs/product.ts

@@ -9,11 +9,23 @@ export async function getMainProductName(subscriptionId: string): Promise<string
   });
   const priceId: string = checkoutSession?.line_items.find((x) => !x.cross_sell)?.price_id as string;
 
+  if (!priceId) {
+    throw new Error(`PriceId can't be found by subscriptionId(${subscriptionId})`);
+  }
+
   const price = await Price.findByPk(priceId, {
     attributes: ['product_id'],
   });
 
-  const product = (await Product.findByPk(price?.product_id)) as Product;
+  if (!price) {
+    throw new Error(`Price can't be found by priceId(${priceId})`);
+  }
+
+  const product = await Product.findByPk(price?.product_id);
+
+  if (!product) {
+    throw new Error(`Product can't be found by productId(${price?.product_id})`);
+  }
 
   return product.name;
 }

package/api/src/schedule/base.ts

@@ -0,0 +1,199 @@
+import dayjs from 'dayjs';
+import { clone } from 'lodash';
+import pAll from 'p-all';
+
+import { NotificationQueueJob, notificationQueue } from '../jobs/notification';
+import { notificationCronConcurrency } from '../libs/env';
+import logger from '../libs/logger';
+import type { SubscriptionTrialWillEndEmailTemplateOptions } from '../libs/notification/template/subscription-trial-will-end';
+import type { Subscription } from '../store/models';
+import type { Diff } from './interface/diff';
+
+export interface BaseSubscriptionScheduleNotificationSubscription extends Subscription {
+  diffs: Diff[];
+}
+
+export type BaseSubscriptionScheduleNotificationEventType =
+  | 'customer.subscription.trial_will_end'
+  | 'customer.subscription.will_renew';
+
+type Task<Options> = {
+  id: string;
+  job: { type: NotificationQueueJob['type']; options: Options };
+  delay: number;
+};
+
+export abstract class BaseSubscriptionScheduleNotification {
+  readonly start: number;
+  readonly end: number;
+  abstract eventType: BaseSubscriptionScheduleNotificationEventType;
+
+  constructor() {
+    this.start = Date.now();
+    this.end = dayjs(this.start).add(1, 'M').add(1, 'd').toDate().getTime();
+  }
+
+  abstract getSubscriptions(): Promise<Subscription[]>;
+
+  async run() {
+    const label: string = new Date().toISOString();
+
+    logger.info(`${label}: ${this.constructor.name}.run start`);
+
+    const subscriptions = await this.getSubscriptions();
+    const subscriptionForWillRenew = this.getSubscriptionsForWillRenew(subscriptions);
+
+    await this.addTaskToQueue(subscriptionForWillRenew);
+
+    logger.info(`${label}: ${this.constructor.name}.run end`);
+  }
+
+  static DIFFS: Diff[] = [
+    {
+      value: 1,
+      unit: 'M',
+    },
+    {
+      value: 7,
+      unit: 'd',
+    },
+    {
+      value: 3,
+      unit: 'd',
+    },
+    {
+      value: 1,
+      unit: 'd',
+    },
+    {
+      value: 6,
+      unit: 'h',
+    },
+    {
+      value: 30,
+      unit: 'm',
+    },
+  ];
+  /**
+   * @see https://github.com/blocklet/payment-kit/issues/236#issuecomment-1824129965
+   * @description
+   * @param {Subscription[]} subscriptions
+   * @return {*}  {SubscriptionForWillRenew[]}
+   * @memberof SubscriptionWillRenewSchedule
+   */
+  getSubscriptionsForWillRenew(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;
+
+      if (
+        dayjs(currentPeriodEnd).diff(this.start, 'M') >= 1 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(0);
+      } else if (
+        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 7 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(1);
+      } else if (
+        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 3 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 3
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(2);
+      } else if (
+        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 1 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 1
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(3);
+      } else if (
+        dayjs(currentPeriodEnd).diff(this.start, 'h') >= 6 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') > 6
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(4);
+      } else if (
+        dayjs(currentPeriodEnd).diff(this.start, 'm') >= 30 &&
+        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'm') > 30
+      ) {
+        s.diffs = BaseSubscriptionScheduleNotification.DIFFS.slice(5);
+      } else {
+        s.diffs = [];
+      }
+
+      // 每一个周期都至少收到一封邮件
+      if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1) {
+        s.diffs.forEach((x) => {
+          if (x.value === 7 && x.unit === 'd') {
+            x.required = true;
+          }
+        });
+      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7) {
+        s.diffs.forEach((x) => {
+          if (x.value === 3 && x.unit === 'd') {
+            x.required = true;
+          }
+        });
+      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') >= 6) {
+        s.diffs.forEach((x) => {
+          if (x.value === 6 && x.unit === 'h') {
+            x.required = true;
+          }
+        });
+      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'm') >= 30) {
+        s.diffs.forEach((x) => {
+          if (x.value === 30 && x.unit === 'm') {
+            x.required = true;
+          }
+        });
+      }
+
+      return s;
+    });
+  }
+
+  async addTaskToQueue<Options extends SubscriptionTrialWillEndEmailTemplateOptions>(
+    subscriptions: BaseSubscriptionScheduleNotificationSubscription[]
+  ): Promise<void> {
+    const type = this.eventType;
+
+    const tasks: Task<Options>[] = [];
+    for (const subscription of subscriptions) {
+      for (const diff of subscription.diffs) {
+        const task: Task<Options> = {
+          id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
+          job: {
+            type,
+            options: {
+              subscriptionId: subscription.id,
+              willRenewValue: diff.value,
+              willRenewUnit: diff.unit,
+              required: !!diff.required,
+            } as Options,
+          },
+          delay: dayjs(subscription.current_period_end * 1000)
+            .subtract(diff.value, diff.unit)
+            .diff(this.start, 's'),
+        };
+
+        tasks.push(task);
+      }
+    }
+
+    await pAll(
+      tasks.map((x) => {
+        return async () => {
+          const job = await notificationQueue.get(x.id);
+          if (job) {
+            return;
+          }
+
+          notificationQueue.push(x);
+        };
+      }),
+      { concurrency: notificationCronConcurrency }
+    );
+  }
+}

package/api/src/schedule/subscription-trail-will-end.ts

@@ -1,42 +1,11 @@
 /* eslint-disable no-console */
-import dayjs from 'dayjs';
-import { clone } from 'lodash';
-import pAll from 'p-all';
 import { Op } from 'sequelize';
 
-import { NotificationQueueJob, notificationQueue } from '../jobs/notification';
-import { notificationCronConcurrency } from '../libs/env';
-import logger from '../libs/logger';
-import type { SubscriptionTrialWillEndEmailTemplateOptions } from '../libs/notification/template/subscription-trial-will-end';
 import { Subscription } from '../store/models';
-import type { Diff } from './interface/diff';
+import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
 
-interface SubscriptionForTrailWillEnd extends Subscription {
-  diffs: Diff[];
-}
-
-export class SubscriptionTrailWillEndSchedule {
-  private start: number;
-
-  private end: number;
-
-  constructor() {
-    this.start = Date.now();
-    this.end = dayjs(this.start).add(1, 'M').add(1, 'd').toDate().getTime();
-  }
-
-  async run() {
-    const label: string = new Date().toISOString();
-
-    logger.info(`${label}: SubscriptionTrailWillEndSchedule.run start`);
-
-    const subscriptions = await this.getSubscriptions();
-    const subscriptionForWillRenew = this.getSubscriptionsForWillRenew(subscriptions);
-
-    await this.addTaskToQueue(subscriptionForWillRenew);
-
-    logger.info(`${label}: SubscriptionTrailWillEndSchedule.run end`);
-  }
+export class SubscriptionTrailWillEndSchedule extends BaseSubscriptionScheduleNotification {
+  override eventType: BaseSubscriptionScheduleNotificationEventType = 'customer.subscription.trial_will_end';
 
   async getSubscriptions(): Promise<Subscription[]> {
     const subscriptions = await Subscription.findAll({
@@ -58,140 +27,4 @@ export class SubscriptionTrailWillEndSchedule {
 
     return subscriptions;
   }
-
-  static DIFFS: Diff[] = [
-    {
-      value: 1,
-      unit: 'M',
-    },
-    {
-      value: 7,
-      unit: 'd',
-    },
-    {
-      value: 3,
-      unit: 'd',
-    },
-    {
-      value: 1,
-      unit: 'd',
-    },
-    {
-      value: 6,
-      unit: 'h',
-    },
-  ];
-
-  /**
-   * @see https://github.com/blocklet/payment-kit/issues/236#issuecomment-1824129965
-   * @description
-   * @param {Subscription[]} subscriptions
-   * @return {*}  {SubscriptionForWillRenew[]}
-   * @memberof SubscriptionWillRenewSchedule
-   */
-  getSubscriptionsForWillRenew(subscriptions: Subscription[]): SubscriptionForTrailWillEnd[] {
-    return subscriptions.map((subscription: Subscription): SubscriptionForTrailWillEnd => {
-      const s: SubscriptionForTrailWillEnd = clone(subscription) as SubscriptionForTrailWillEnd;
-      const currentPeriodStart: number = s.current_period_start * 1000;
-      const currentPeriodEnd: number = s.current_period_end * 1000;
-
-      if (
-        dayjs(currentPeriodEnd).diff(this.start, 'M') >= 1 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1
-      ) {
-        s.diffs = SubscriptionTrailWillEndSchedule.DIFFS.slice(0);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 7 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7
-      ) {
-        s.diffs = SubscriptionTrailWillEndSchedule.DIFFS.slice(1);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 3 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 3
-      ) {
-        s.diffs = SubscriptionTrailWillEndSchedule.DIFFS.slice(2);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 1 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 1
-      ) {
-        s.diffs = SubscriptionTrailWillEndSchedule.DIFFS.slice(3);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'h') >= 6 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') > 6
-      ) {
-        s.diffs = SubscriptionTrailWillEndSchedule.DIFFS.slice(4);
-      } else {
-        s.diffs = [];
-      }
-
-      // 每一个周期都至少收到一封邮件
-      if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1) {
-        s.diffs.forEach((x) => {
-          if (x.value === 7 && x.unit === 'd') {
-            x.required = true;
-          }
-        });
-      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7) {
-        s.diffs.forEach((x) => {
-          if (x.value === 3 && x.unit === 'd') {
-            x.required = true;
-          }
-        });
-      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') >= 6) {
-        s.diffs.forEach((x) => {
-          if (x.value === 6 && x.unit === 'h') {
-            x.required = true;
-          }
-        });
-      }
-
-      return s;
-    });
-  }
-
-  async addTaskToQueue(subscriptions: SubscriptionForTrailWillEnd[]): Promise<void> {
-    const tasks: {
-      id: string;
-      job: { type: NotificationQueueJob['type']; options: SubscriptionTrialWillEndEmailTemplateOptions };
-      delay: number;
-    }[] = [];
-
-    for (const subscription of subscriptions) {
-      for (const diff of subscription.diffs) {
-        const id: string = `${subscription.id}.${diff.value}.${diff.unit}`;
-        const job: { type: NotificationQueueJob['type']; options: SubscriptionTrialWillEndEmailTemplateOptions } = {
-          type: 'customer.subscription.trial_will_end',
-          options: {
-            subscriptionId: subscription.id,
-            willRenewValue: diff.value,
-            willRenewUnit: diff.unit,
-            required: !!diff.required,
-          },
-        };
-        const delay: number = dayjs(subscription.current_period_end * 1000)
-          .subtract(diff.value, diff.unit)
-          .diff(this.start, 's');
-
-        tasks.push({
-          id,
-          job,
-          delay,
-        });
-      }
-    }
-
-    await pAll(
-      tasks.map((x) => {
-        return async () => {
-          const job = await notificationQueue.get(x.id);
-          if (job) {
-            return;
-          }
-
-          notificationQueue.push(x);
-        };
-      }),
-      { concurrency: notificationCronConcurrency }
-    );
-  }
 }

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

@@ -1,42 +1,11 @@
 /* eslint-disable no-console */
-import dayjs from 'dayjs';
-import { clone } from 'lodash';
-import pAll from 'p-all';
 import { Op } from 'sequelize';
 
-import { NotificationQueueJob, notificationQueue } from '../jobs/notification';
-import { notificationCronConcurrency } from '../libs/env';
-import logger from '../libs/logger';
-import type { SubscriptionWillRenewEmailTemplateOptions } from '../libs/notification/template/subscription-will-renew';
 import { Subscription } from '../store/models';
-import type { Diff } from './interface/diff';
+import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
 
-interface SubscriptionForWillRenew extends Subscription {
-  diffs: Diff[];
-}
-
-export class SubscriptionWillRenewSchedule {
-  private start: number;
-
-  private end: number;
-
-  constructor() {
-    this.start = Date.now();
-    this.end = dayjs(this.start).add(1, 'M').add(1, 'd').toDate().getTime();
-  }
-
-  async run() {
-    const label: string = new Date().toISOString();
-
-    logger.info(`${label}: SubscriptionWillRenewSchedule.run start`);
-
-    const subscriptions = await this.getSubscriptions();
-    const subscriptionForWillRenew = this.getSubscriptionsForWillRenew(subscriptions);
-
-    await this.addTaskToQueue(subscriptionForWillRenew);
-
-    logger.info(`${label}: SubscriptionWillRenewSchedule.run end`);
-  }
+export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotification {
+  override eventType: BaseSubscriptionScheduleNotificationEventType = 'customer.subscription.will_renew';
 
   async getSubscriptions(): Promise<Subscription[]> {
     const subscriptions = await Subscription.findAll({
@@ -56,140 +25,4 @@ export class SubscriptionWillRenewSchedule {
 
     return subscriptions;
   }
-
-  static DIFFS: Diff[] = [
-    {
-      value: 1,
-      unit: 'M',
-    },
-    {
-      value: 7,
-      unit: 'd',
-    },
-    {
-      value: 3,
-      unit: 'd',
-    },
-    {
-      value: 1,
-      unit: 'd',
-    },
-    {
-      value: 6,
-      unit: 'h',
-    },
-  ];
-
-  /**
-   * @see https://github.com/blocklet/payment-kit/issues/236#issuecomment-1824129965
-   * @description
-   * @param {Subscription[]} subscriptions
-   * @return {*}  {SubscriptionForWillRenew[]}
-   * @memberof SubscriptionWillRenewSchedule
-   */
-  getSubscriptionsForWillRenew(subscriptions: Subscription[]): SubscriptionForWillRenew[] {
-    return subscriptions.map((subscription: Subscription): SubscriptionForWillRenew => {
-      const s: SubscriptionForWillRenew = clone(subscription) as SubscriptionForWillRenew;
-      const currentPeriodStart: number = s.current_period_start * 1000;
-      const currentPeriodEnd: number = s.current_period_end * 1000;
-
-      if (
-        dayjs(currentPeriodEnd).diff(this.start, 'M') >= 1 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1
-      ) {
-        s.diffs = SubscriptionWillRenewSchedule.DIFFS.slice(0);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 7 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7
-      ) {
-        s.diffs = SubscriptionWillRenewSchedule.DIFFS.slice(1);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 3 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 3
-      ) {
-        s.diffs = SubscriptionWillRenewSchedule.DIFFS.slice(2);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'd') >= 1 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 1
-      ) {
-        s.diffs = SubscriptionWillRenewSchedule.DIFFS.slice(3);
-      } else if (
-        dayjs(currentPeriodEnd).diff(this.start, 'h') >= 6 &&
-        dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') > 6
-      ) {
-        s.diffs = SubscriptionWillRenewSchedule.DIFFS.slice(4);
-      } else {
-        s.diffs = [];
-      }
-
-      // 每一个周期都至少收到一封邮件
-      if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'M') > 1) {
-        s.diffs.forEach((x) => {
-          if (x.value === 7 && x.unit === 'd') {
-            x.required = true;
-          }
-        });
-      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'd') > 7) {
-        s.diffs.forEach((x) => {
-          if (x.value === 3 && x.unit === 'd') {
-            x.required = true;
-          }
-        });
-      } else if (dayjs(currentPeriodEnd).diff(currentPeriodStart, 'h') >= 6) {
-        s.diffs.forEach((x) => {
-          if (x.value === 6 && x.unit === 'h') {
-            x.required = true;
-          }
-        });
-      }
-
-      return s;
-    });
-  }
-
-  async addTaskToQueue(subscriptions: SubscriptionForWillRenew[]): Promise<void> {
-    const tasks: {
-      id: string;
-      job: { type: NotificationQueueJob['type']; options: SubscriptionWillRenewEmailTemplateOptions };
-      delay: number;
-    }[] = [];
-
-    for (const subscription of subscriptions) {
-      for (const diff of subscription.diffs) {
-        const id: string = `${subscription.id}.${diff.value}.${diff.unit}`;
-        const job: { type: NotificationQueueJob['type']; options: SubscriptionWillRenewEmailTemplateOptions } = {
-          type: 'customer.subscription.will_renew',
-          options: {
-            subscriptionId: subscription.id,
-            willRenewValue: diff.value,
-            willRenewUnit: diff.unit,
-            required: !!diff.required,
-          },
-        };
-        const delay: number = dayjs(subscription.current_period_end * 1000)
-          .subtract(diff.value, diff.unit)
-          .diff(this.start, 's');
-
-        tasks.push({
-          id,
-          job,
-          delay,
-        });
-      }
-    }
-
-    await pAll(
-      tasks.map((x) => {
-        return async () => {
-          const job = await notificationQueue.get(x.id);
-          if (job) {
-            return;
-          }
-
-          notificationQueue.push(x);
-        };
-      }),
-      { concurrency: notificationCronConcurrency }
-    );
-  }
 }

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.13.69
+version: 1.13.71
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.13.69",
+  "version": "1.13.71",
   "scripts": {
     "dev": "COMPONENT_STORE_URL=https://test.store.blocklet.dev blocklet dev",
     "eject": "vite eject",
@@ -106,7 +106,7 @@
     "@abtnode/types": "^1.16.19",
     "@arcblock/eslint-config": "^0.2.4",
     "@arcblock/eslint-config-ts": "^0.2.4",
-    "@did-pay/types": "1.13.69",
+    "@did-pay/types": "1.13.71",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
     "@types/dotenv-flow": "^3.3.3",
@@ -143,5 +143,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "fd169e0529e664ecf8257e684029f21629d39113"
+  "gitHead": "790a7f2f0e18c1631bf018ca5481b01ec25996e3"
 }