payment-kit 1.13.64 → 1.13.66

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

@@ -0,0 +1,232 @@
+/* eslint-disable @typescript-eslint/brace-style */
+/* eslint-disable @typescript-eslint/indent */
+import { fromUnitToToken } from '@ocap/util';
+import type { ManipulateType } from 'dayjs';
+import prettyMsI18n from 'pretty-ms-i18n';
+
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { Customer, Invoice, Subscription } from '../../../store/models';
+import { PaymentCurrency } from '../../../store/models/payment-currency';
+import { PaymentDetail, getPaymentDetail } from '../../payment';
+import { getMainProductName } from '../../product';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+
+export interface SubscriptionWillRenewEmailTemplateOptions {
+  subscriptionId: string;
+  willRenewValue: number;
+  willRenewUnit: ManipulateType;
+  required?: false | true;
+}
+
+interface SubscriptionWillRenewEmailTemplateContext {
+  locale: string;
+  productName: string;
+  at: string;
+  willRenewDuration: string;
+  paymentDetail: PaymentDetail;
+
+  userDid: string;
+  paymentInfo: string;
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  duration: string;
+
+  viewSubscriptionLink: string;
+}
+
+export class SubscriptionWillRenewEmailTemplate
+  implements BaseEmailTemplate<SubscriptionWillRenewEmailTemplateContext>
+{
+  options: SubscriptionWillRenewEmailTemplateOptions;
+
+  constructor(options: SubscriptionWillRenewEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<SubscriptionWillRenewEmailTemplateContext> {
+    const subscription: Subscription | null = await Subscription.findByPk(this.options.subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${subscription.customer_id}`);
+    }
+
+    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: subscription.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const locale = await getUserLocale(customer.did);
+    const productName = await getMainProductName(subscription.id);
+    const at: string = formatTime(invoice.period_end * 1000);
+    const willRenewDuration: string =
+      locale === 'en' ? this.getWillRenewDuration(locale) : this.getWillRenewDuration(locale).replaceAll(' ', '');
+
+    const userDid = customer.did;
+    const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
+    const paymentInfo: string = `${fromUnitToToken(+invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    const currentPeriodStart: string = formatTime(invoice.period_start * 1000);
+    const currentPeriodEnd: string = formatTime(invoice.period_end * 1000);
+    const duration: string = prettyMsI18n(
+      new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
+      {
+        locale: getPrettyMsI18nLocale(locale),
+      }
+    );
+
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl(subscription.id, locale);
+
+    return {
+      locale,
+      productName,
+      at,
+      willRenewDuration,
+      paymentDetail,
+
+      userDid,
+      paymentInfo,
+      currentPeriodStart,
+      currentPeriodEnd,
+      duration,
+
+      viewSubscriptionLink,
+    };
+  }
+
+  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,
+      paymentDetail,
+
+      userDid,
+      paymentInfo,
+
+      viewSubscriptionLink,
+    } = await this.getContext();
+
+    const canPay: boolean = paymentDetail.balance >= paymentDetail.price;
+    if (canPay && !this.options.required) {
+      // 当余额足够支付并且本封邮件不是必须发送时,可以不发送邮件
+      return null;
+    }
+
+    const template: BaseEmailTemplateType = {
+      title: `${translate('notification.subscriptionWillRenew.title', locale, {
+        productName: `(${productName})`,
+        willRenewDuration,
+      })}`,
+      body: canPay
+        ? `${translate('notification.subscriptionWillRenew.body', locale, {
+            at,
+            productName: `(${productName})`,
+            willRenewDuration,
+          })}`
+        : `${translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
+            at,
+            productName: `(${productName})`,
+            willRenewDuration,
+            balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
+            price: `${paymentDetail.price} ${paymentDetail.symbol}`,
+          })}`,
+      // @ts-expect-error
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.account', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: userDid,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.product', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: productName,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.subscriptionWillRenew.renewAmount', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: paymentInfo,
+              },
+            },
+          ].filter(Boolean),
+        },
+      ].filter(Boolean),
+      // @ts-ignore
+      actions: [
+        {
+          name: 'viewSubscription',
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

package/api/src/libs/payment.ts

@@ -1,20 +1,35 @@
+/* eslint-disable @typescript-eslint/indent */
 import { toDelegateAddress } from '@arcblock/did-util';
 import { sign } from '@arcblock/jwt';
 import { getWalletDid } from '@blocklet/sdk/lib/did';
 import type { DelegateState } from '@ocap/client';
 import { toTxHash } from '@ocap/mcrypto';
-import { BN } from '@ocap/util';
+import { BN, fromUnitToToken } from '@ocap/util';
 
+import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod } from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
-import type { PaymentMethod } from '../store/models/payment-method';
 import { blocklet, wallet } from './auth';
+import logger from './logger';
+
+export interface SufficientForPaymentResult {
+  sufficient: boolean;
+  reason?:
+    | 'NO_DID_WALLET'
+    | 'NO_DELEGATION'
+    | 'NO_TRANSFER_PERMISSION'
+    | 'NO_TOKEN'
+    | 'NO_ENOUGH_TOKEN'
+    | 'NOT_SUPPORTED';
+  delegator?: string;
+  state?: DelegateState;
+}
 
 export async function isDelegationSufficientForPayment(args: {
   paymentMethod: PaymentMethod;
   paymentCurrency: TPaymentCurrency;
   userDid: string;
   amount: string;
-}): Promise<{ sufficient: boolean; reason?: string; delegator?: string; state?: DelegateState }> {
+}): Promise<SufficientForPaymentResult> {
   const { paymentCurrency, paymentMethod, userDid, amount } = args;
   if (paymentMethod.type === 'arcblock') {
     // user have bond wallet did?
@@ -67,3 +82,85 @@ export function getGasPayerExtra(txBuffer: Buffer) {
     },
   };
 }
+
+export interface PaymentDetail {
+  balance: number;
+  price: number;
+  symbol: string;
+}
+export async function getPaymentDetail(userDid: string, invoice: Invoice): Promise<PaymentDetail> {
+  const defaultResult = {
+    balance: 0,
+    price: 0,
+    symbol: '',
+  };
+
+  const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+  if (!paymentIntent) {
+    logger.error('getPayment.error', { reason: 'NO_PAYMENT_INTENT' });
+    return defaultResult;
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentIntent?.payment_method_id);
+  if (!paymentMethod) {
+    logger.error('getPayment.error', { reason: 'NO_PAYMENT_METHOD' });
+    return defaultResult;
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(paymentIntent.currency_id);
+  if (!paymentCurrency) {
+    logger.error('getPayment.error', { reason: 'NO_PAYMENT_CURRENCY' });
+    return defaultResult;
+  }
+
+  if (paymentMethod.type === 'arcblock') {
+    // user have bond wallet did?
+    const { user } = await blocklet.getUser(userDid, { enableConnectedAccount: true });
+    const delegator = getWalletDid(user);
+    if (!delegator) {
+      logger.error('getPayment.error', { reason: 'NO_DID_WALLET' });
+      return defaultResult;
+    }
+
+    const client = paymentMethod.getOcapClient();
+
+    // have delegated before?
+    const address = toDelegateAddress(delegator, wallet.address);
+    const { state } = await client.getDelegateState({ address });
+    if (!state) {
+      logger.error('getPayment.error', { reason: 'NO_DELEGATION' });
+      return defaultResult;
+    }
+
+    // have enough permissions
+    if (state.ops.some((x: any) => x.key === 'fg:t:transfer_v2') === false) {
+      logger.error('getPayment.error', { reason: 'NO_TRANSFER_PERMISSION' });
+      return defaultResult;
+    }
+
+    // balance enough token for payment?
+    const amount: number = +fromUnitToToken(paymentIntent.amount, paymentCurrency.decimal);
+    const { symbol } = paymentCurrency;
+
+    const { tokens } = await client.getAccountTokens({
+      address: delegator,
+      token: paymentCurrency.contract as string,
+    });
+    const [token] = tokens;
+    if (!token) {
+      return {
+        balance: 0,
+        price: amount,
+        symbol,
+      };
+    }
+
+    return {
+      balance: +fromUnitToToken(token.balance, paymentCurrency.decimal),
+      price: amount,
+      symbol,
+    };
+  }
+
+  return defaultResult;
+}

package/api/src/libs/product.ts

@@ -0,0 +1,19 @@
+import { CheckoutSession, Price, Product } from '../store/models';
+
+export async function getMainProductName(subscriptionId: string): Promise<string> {
+  const checkoutSession = await CheckoutSession.findOne({
+    where: {
+      subscription_id: subscriptionId,
+    },
+    attributes: ['line_items'],
+  });
+  const priceId: string = checkoutSession?.line_items.find((x) => !x.cross_sell)?.price_id as string;
+
+  const price = await Price.findByPk(priceId, {
+    attributes: ['product_id'],
+  });
+
+  const product = (await Product.findByPk(price?.product_id)) as Product;
+
+  return product.name;
+}

package/api/src/libs/queue/index.ts

@@ -198,6 +198,18 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
     return doc ? doc.job : null;
   };
 
+  const deleteJob = async (id: string): Promise<boolean> => {
+    const exists = await getJob(id);
+
+    if (exists) {
+      await cancel(id);
+      await store.deleteJob(id);
+      return true;
+    }
+
+    return false;
+  };
+
   // Populate the queue on startup
   process.nextTick(async () => {
     try {
@@ -251,6 +263,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
     saturated: (cb: any) => (queue.saturated = cb),
     error: (cb: any) => (queue.error = cb),
     get: getJob,
+    delete: deleteJob,
     cancel,
     options: {
       concurrency,

package/api/src/libs/subscription.ts

@@ -0,0 +1,5 @@
+import { component } from '@blocklet/sdk';
+
+export function getCustomerSubscriptionPageUrl(subscriptionId: string, locale: string = 'en') {
+  return component.getUrl(`customer/subscription/${subscriptionId}?locale=${locale}`);
+}

package/api/src/libs/time.ts

@@ -0,0 +1,17 @@
+import type { LiteralUnion } from 'type-fest';
+
+import dayjs from './dayjs';
+
+export function formatTime(time: dayjs.ConfigType): string {
+  return dayjs(time).utc().format('YYYY-MM-DD HH:mm:ss [UTC]');
+}
+
+export function getPrettyMsI18nLocale(
+  locale: LiteralUnion<'en' | 'zh', string> = 'en'
+): LiteralUnion<'zh_CN' | 'en', string> {
+  if (locale === 'zh' || locale === 'zh_CN') {
+    return 'zh_CN';
+  }
+
+  return 'en';
+}

package/api/src/libs/util.ts

@@ -3,6 +3,7 @@ import crypto from 'crypto';
 import { getUrl } from '@blocklet/sdk/lib/component';
 import env from '@blocklet/sdk/lib/env';
 import { customAlphabet } from 'nanoid';
+import type { LiteralUnion } from 'type-fest';
 
 import dayjs from './dayjs';
 
@@ -154,3 +155,41 @@ export function getMetadataFromQuery(query: Record<string, any> = {}): Record<st
 
   return metadata;
 }
+
+// @FIXME: 这个应该封装在某个通用类库里面 @jianchao @wangshijun
+export function getExplorerLink(
+  chainHost: string | undefined,
+  did: string | undefined,
+  type: LiteralUnion<'asset' | 'account' | 'tx' | 'token' | 'factory' | ' bridge', string>
+) {
+  if (!chainHost) return undefined;
+  try {
+    const chainUrl = new URL(chainHost);
+    switch (type) {
+      case 'asset':
+        chainUrl.pathname = `/explorer/assets/${did}`;
+        break;
+      case 'account':
+        chainUrl.pathname = `/explorer/accounts/${did}`;
+        break;
+      case 'tx':
+        chainUrl.pathname = `/explorer/txs/${did}`;
+        break;
+      case 'token':
+        chainUrl.pathname = `/explorer/tokens/${did}`;
+        break;
+      case 'factory':
+        chainUrl.pathname = `/explorer/factories/${did}`;
+        break;
+      case 'bridge':
+        chainUrl.pathname = `/explorer/bridges/${did}`;
+        break;
+      default:
+        chainUrl.pathname = '/';
+    }
+
+    return chainUrl.href;
+  } catch {
+    return undefined;
+  }
+}

package/api/src/locales/en.ts

@@ -2,10 +2,77 @@ import flat from 'flat';
 
 export default flat({
   notification: {
+    common: {
+      account: 'Account',
+      product: 'Product',
+      paymentInfo: 'Payment Info',
+      validityPeriod: 'Validity period',
+      trialPeriod: 'Trail period',
+      viewSubscription: 'View subscription',
+      viewInvoice: 'View invoice',
+      viewTxHash: 'View transaction',
+      trialDuration: 'Trial duration',
+      duration: 'Duration',
+      nftAddress: 'NFT Address',
+      month: 'month',
+      months: 'months',
+      day: 'day',
+      days: 'days',
+      minute: 'minute',
+      minutes: 'minutes',
+    },
+
     sendTo: 'Sent to',
     mintNFT: {
       title: '{collection} NFT minted',
       message: 'A new {collection} NFT is minted and sent to your wallet, please check it out.',
     },
+
+    subscriptionTrialStart: {
+      title: 'Welcome to the start of your {productName} trial',
+      body: 'Congratulations on your {productName} trial! The length of the trial is {trialDuration} and will end at {subscriptionTrialEnd}. Have fun with {productName}!',
+    },
+
+    subscriptionTrialWillEnd: {
+      title: 'The {productName} trial will end soon',
+      body: 'Your {productName} trial subscription will end after {willRenewDuration}. Please make sure your account balance is sufficient to automatically renew your subscription at the end of the trial period. Thank you for your support and trust!',
+      unableToPayBody:
+        'Your {productName} trial subscription will end after {willRenewDuration}.<span style="color: red;">Your current balance is {balance}, which is less than {price}</span>，please make sure your balance is sufficient for automatic renewal. Thank you for your support and trust!',
+    },
+
+    subscriptionSucceed: {
+      title: "Congratulations! You've successfully subscribed to {productName}",
+      body: 'Thank you for successfully subscribing to {productName} on {at}. We will be happy to provide you with excellent service, and we wish you a pleasant experience.',
+    },
+
+    subscriptionWillRenew: {
+      title: '{productName} will be auto-renewed soon',
+      body: 'Your subscription to {productName} and {willRenewDuration} is expiring. Please make sure you have enough balance in your account to auto-renew your subscription when it expires ({at}). We wish you all the best!',
+      unableToPayBody:
+        'Your subscription to {productName} and {willRenewDuration} expires. <span style="color: red;">Your current balance is {balance}, which is less than {price}</span>, so please make sure you have enough balance in your account to automatically renew your subscription when it expires ({at}). We wish you all the best!',
+      renewAmount: 'Amount',
+    },
+
+    subscriptionRenewed: {
+      title: '{productName} Renewal Successful',
+      body: 'Your {productName} was successfully renewed on {at}. Thank you for your continued support and trust, have a great day!',
+    },
+
+    subscriptionRenewFailed: {
+      title: 'Renewal of {productName} failed',
+      body: "We're sorry to inform you that your {productName} renewal failed on {at}. The reason for the failure is <span style='color: red;'>{reason}</span>. If you have any questions, please do not hesitate to contact us. Thank you.",
+      renewNow: 'Renew now',
+      reason: {
+        noDidWallet:
+          'You have not yet bound the DID Wallet, please bind the DID Wallet, make sure the balance is sufficient and then renew it',
+        noDelegation: 'Your DID Wallet is not yet authorized, please renew it after completing the authorization',
+        noTransferPermission:
+          'Your DID Wallet transfer privileges are insufficient, please complete the authorization and renew it again',
+        noToken: "You don't have any tokens in your account, please replenish your tokens and renew your account",
+        noEnoughToken:
+          'Your account token balance is {balance}, not enough for {price}, please replenish your tokens and renew your account',
+        noSupported: 'Token renewal is not supported, please check your subscription',
+      },
+    },
   },
 });

package/api/src/locales/zh.ts

@@ -2,10 +2,74 @@ import flat from 'flat';
 
 export default flat({
   notification: {
+    common: {
+      account: '账号',
+      product: '商品',
+      paymentInfo: '支付信息',
+      validityPeriod: '有效期',
+      trialPeriod: '试用期',
+      viewSubscription: '查看订阅',
+      viewInvoice: '查看发票',
+      viewTxHash: '查看交易',
+      trialDuration: '试用期时长',
+      duration: '时长',
+      nftAddress: 'NFT 地址',
+      month: '个月',
+      months: '个月',
+      day: '天',
+      days: '天',
+      minute: '分钟',
+      minutes: '分钟',
+    },
+
     sendTo: '发送给',
     mintNFT: {
       title: '{collection} NFT 铸造成功',
       message: '{collection} NFT 已经铸造完成并发送到你的钱包，请查收',
     },
+
+    subscriptionTrialStart: {
+      title: '欢迎开始您的 {productName} 试用之旅',
+      body: '恭喜您获得了 {productName} 的试用资格！试用期时长为 {trialDuration}，将于 {subscriptionTrialEnd} 结束。祝您使用愉快！',
+    },
+
+    subscriptionTrialWillEnd: {
+      title: '{productName} 试用期即将结束',
+      body: '您订阅的 {productName} 试用资格将在 {willRenewDuration} 后结束。请确保您的账户余额充足，以便在试用期结束后自动续费。感谢您的支持与信任！',
+      unableToPayBody:
+        '您订阅的 {productName} 试用资格将在 {willRenewDuration} 后结束。<span style="color: red;">您的当前余额为 {balance}，不足 {price}</span>，请确保余额充足以便自动续费。感谢您的支持与信任！',
+    },
+
+    subscriptionSucceed: {
+      title: '恭喜！您已成功订阅 {productName}',
+      body: '感谢您于 {at} 成功订阅了 {productName}。我们将竭诚为您提供优质的服务，祝您使用愉快！',
+    },
+
+    subscriptionWillRenew: {
+      title: '{productName} 即将自动续费',
+      body: '您订阅的 {productName} 还有 {willRenewDuration} 到期。请确保您的账户余额充足，以便在到期后({at})自动续费。祝您一切顺利！',
+      unableToPayBody:
+        '您订阅的 {productName} 还有 {willRenewDuration} 到期。<span style="color: red;">您的当前余额为 {balance}，不足 {price}</span>，请确保您的账户余额充足，以便在到期后({at})自动续费。祝您一切顺利！',
+      renewAmount: '扣款金额',
+    },
+
+    subscriptionRenewed: {
+      title: '{productName} 续费成功',
+      body: '您的 {productName} 已于 {at} 成功续费。感谢您的持续支持与信任，祝您使用愉快！',
+    },
+
+    subscriptionRenewFailed: {
+      title: '{productName} 续费失败',
+      body: '很抱歉地通知您，您的 {productName} 续费于 {at} 失败。失败原因为 <span style="color: red;">{reason}</span>。如有任何疑问，请及时联系我们。谢谢！',
+      renewNow: '立即续费',
+      reason: {
+        noDidWallet: '您尚未绑定 DID Wallet，请绑定 DID Wallet，确保余额充足后重新续费',
+        noDelegation: '您的 DID Wallet 尚未授权，请完成授权后重新续费',
+        noTransferPermission: '您的 DID Wallet 转账权限不足，请完成授权后重新续费',
+        noToken: '您的账户没有任何代币，请充值代币后重新续费',
+        noEnoughToken: '您的账户代币余额为 {balance}，不足 {price}，请充值代币后重新续费',
+        noSupported: '不支持使用代币续费，请检查您的套餐',
+      },
+    },
   },
 });

package/api/src/routes/connect/collect.ts

@@ -5,8 +5,10 @@ import { invoiceQueue } from '../../jobs/invoice';
 import { handlePaymentSucceed, paymentQueue } from '../../jobs/payment';
 import type { CallbackArgs } from '../../libs/auth';
 import { wallet } from '../../libs/auth';
+import { events } from '../../libs/event';
 import { getGasPayerExtra } from '../../libs/payment';
 import { getTxMetadata } from '../../libs/util';
+import { Subscription } from '../../store/models';
 import { ensureInvoiceForCollect, getAuthPrincipalClaim } from './shared';
 
 // Used to collect an open invoice failed to collect automatically
@@ -98,6 +100,10 @@ export default {
         await invoiceQueue.cancel(invoice.id);
       }
 
+      if (invoice.subscription_id) {
+        events.emit('customer.subscription.renewed', await Subscription.findByPk(invoice.subscription_id), invoice);
+      }
+
       return { hash: txHash };
     }
 

package/api/src/schedule/index.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import Cron from '@abtnode/cron';
+
+import { notificationCronTime } from '../libs/env';
+import logger from '../libs/logger';
+import { SubscriptionTrailWillEndSchedule } from './subscription-trail-will-end';
+import { SubscriptionWillRenewSchedule } from './subscription-will-renew';
+
+Cron.init({
+  context: {},
+  jobs: [
+    {
+      name: 'subscription.will.renew',
+      time: notificationCronTime,
+      fn: () => new SubscriptionWillRenewSchedule().run(),
+      options: { runOnInit: true },
+    },
+    {
+      name: 'subscription.trial.will.end',
+      time: notificationCronTime,
+      fn: () => new SubscriptionTrailWillEndSchedule().run(),
+      options: { runOnInit: true },
+    },
+  ],
+  onError: (error: Error, name: string) => {
+    logger.error('run job failed', { name, error: error.message, stack: error.stack });
+  },
+});