payment-kit 1.15.16 → 1.15.18

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -4,6 +4,8 @@ import pick from 'lodash/pick';
 import pWaitFor from 'p-wait-for';
 import type Stripe from 'stripe';
 
+import { checkUsageReportEmpty } from '@api/libs/subscription';
+import { createEvent } from '@api/libs/audit';
 import { getLock } from '../../../libs/lock';
 import logger from '../../../libs/logger';
 import {
@@ -256,6 +258,24 @@ export async function handleStripeInvoiceCreated(event: TEventExpanded, client:
   const customer = await Customer.findByPk(subscription.customer_id);
   const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
 
+  if (stripeInvoice.billing_reason === 'subscription_cycle') {
+    // check if usage report is empty
+    const usageReportStart = stripeInvoice.period_start;
+    const usageReportEnd = stripeInvoice.period_end;
+    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,
+      });
+    }
+  }
+
   // create stripe invoice
   const invoice = await ensureStripeInvoice(stripeInvoice, subscription, client);
 

package/api/src/integrations/stripe/resource.ts

@@ -44,7 +44,7 @@ export async function ensureStripeProduct(internal: Product, method: PaymentMeth
     attrs.unit_label = internal.unit_label;
   }
   if (internal.statement_descriptor) {
-    attrs.statement_descriptor_suffix = '';
+    attrs.statement_descriptor = '';
   }
 
   const product = await client.products.create(attrs);
@@ -176,7 +176,7 @@ export async function ensureStripePaymentIntent(
         enabled: true,
         allow_redirects: 'never',
       },
-      statement_descriptor_suffix: '',
+      statement_descriptor: '',
       metadata: {
         appPid: env.appPid,
         id: internal.id,

package/api/src/libs/audit.ts

@@ -33,7 +33,7 @@ export async function createEvent(scope: string, type: LiteralUnion<EventType, s
   });
 
   events.emit('event.created', { id: event.id });
-  events.emit(event.type, data.object);
+  events.emit(event.type, data.object, options);
 }
 
 export async function createStatusEvent(

package/api/src/libs/invoice.ts

@@ -3,9 +3,20 @@ import type { LiteralUnion } from 'type-fest';
 import { withQuery } from 'ufo';
 
 import { fromUnitToToken } from '@ocap/util';
-import { Invoice, InvoiceItem, PaymentCurrency, Price, Product } from '../store/models';
+import {
+  Invoice,
+  InvoiceItem,
+  PaymentCurrency,
+  PaymentMethod,
+  Price,
+  Product,
+  Subscription,
+  SubscriptionItem,
+  UsageRecord,
+} from '../store/models';
 import { getConnectQueryParam } from './util';
 import { expandLineItems } from './session';
+import { getSubscriptionCycleAmount, getSubscriptionCycleSetup } from './subscription';
 
 export function getCustomerInvoicePageUrl({
   invoiceId,
@@ -64,3 +75,72 @@ export async function getOneTimeProductInfo(invoiceId: string, paymentCurrency:
     return [];
   }
 }
+
+export async function getInvoiceShouldPayTotal(invoice: Invoice) {
+  try {
+    const subscription = await Subscription.findByPk(invoice.subscription_id);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${invoice.subscription_id}`);
+    }
+
+    const paymentCurrency = await PaymentCurrency.findByPk(invoice.currency_id);
+    if (!paymentCurrency) {
+      throw new Error(`Payment currency not found: ${invoice.currency_id}`);
+    }
+
+    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+    if (!paymentMethod) {
+      throw new Error(`Payment method not found: ${paymentCurrency.payment_method_id}`);
+    }
+
+    const subscriptionItems = await SubscriptionItem.findAll({
+      where: { subscription_id: subscription.id },
+    });
+
+    let expandedItems = await Price.expand(
+      subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
+      { product: true }
+    );
+
+    const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, invoice.period_start);
+    let offset = 0;
+    let filterFunc = (item: any) => item;
+    if (['arcblock', 'ethereum'].includes(paymentMethod.type)) {
+      switch (invoice.billing_reason) {
+        case 'subscription_cancel':
+          filterFunc = (item: any) => item.price?.recurring?.usage_type === 'metered';
+          break;
+        case 'subscription_cycle':
+          filterFunc = (item: any) => item.price?.type === 'recurring';
+          offset = setup.cycle / 1000;
+          break;
+        default:
+          filterFunc = () => true;
+      }
+    }
+    const previousPeriodStart = setup.period.start - offset;
+    const previousPeriodEnd = setup.period.end - offset;
+    expandedItems = await Promise.all(
+      expandedItems.filter(filterFunc).map(async (item: any) => {
+        const { price } = item;
+        if (price?.recurring?.usage_type === 'metered') {
+          const rawQuantity = await UsageRecord.getSummary({
+            id: item.id,
+            start: previousPeriodStart,
+            end: previousPeriodEnd,
+            method: price.recurring?.aggregate_usage,
+            dryRun: true,
+            searchBilled: false,
+          });
+          item.quantity = price.transformQuantity(rawQuantity);
+        }
+        return item;
+      })
+    );
+    const amount = getSubscriptionCycleAmount(expandedItems, subscription.currency_id);
+    return amount?.total || invoice.total;
+  } catch (err) {
+    console.error(err);
+    return invoice.total;
+  }
+}

package/api/src/libs/notification/template/billing-discrepancy.ts

@@ -0,0 +1,223 @@
+import { fromUnitToToken } from '@ocap/util';
+import prettyMsI18n from 'pretty-ms-i18n';
+import { getOwnerDid } from '../../util';
+import { translate } from '../../../locales';
+import { Invoice, PaymentCurrency, Subscription } from '../../../store/models';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import { getAdminSubscriptionPageUrl, getAdminInvoicePageUrl } from '../../subscription';
+import { getMainProductName } from '../../product';
+import { getInvoiceShouldPayTotal } from '../../invoice';
+
+export interface BillingDiscrepancyEmailTemplateOptions {
+  invoiceId: string;
+}
+
+interface BillingDiscrepancyEmailTemplateContext {
+  locale: string;
+  userDid: string;
+  productName: string;
+  subscriptionId: string;
+  billingAmount: string;
+  shouldPayAmount: string;
+  invoiceId: string;
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  duration: string;
+  viewSubscriptionLink: string;
+  viewInvoiceLink: string;
+}
+
+export class BillingDiscrepancyEmailTemplate implements BaseEmailTemplate<BillingDiscrepancyEmailTemplateContext> {
+  options: BillingDiscrepancyEmailTemplateOptions;
+
+  constructor(options: BillingDiscrepancyEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<BillingDiscrepancyEmailTemplateContext> {
+    const { invoiceId } = this.options;
+    const invoice = await Invoice.findByPk(invoiceId);
+    if (!invoice) {
+      throw new Error(`Invoice not found: ${invoiceId}`);
+    }
+    const subscriptionId = invoice.subscription_id;
+    const subscription: Subscription | null = await Subscription.findByPk(subscriptionId);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${subscriptionId}`);
+    }
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: subscription.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const userDid = await getOwnerDid();
+    if (!userDid) {
+      throw new Error('get owner did failed');
+    }
+    const locale = await getUserLocale(userDid);
+    const productName = await getMainProductName(subscription.id);
+    const currentPeriodStart = formatTime(invoice.period_start * 1000);
+    const currentPeriodEnd = formatTime(invoice.period_end * 1000);
+    const duration: string = prettyMsI18n(
+      new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
+      {
+        locale: getPrettyMsI18nLocale(locale),
+      }
+    );
+    const viewSubscriptionLink = getAdminSubscriptionPageUrl({
+      subscriptionId: subscription.id,
+      locale,
+      userDid,
+    });
+    const viewInvoiceLink = getAdminInvoicePageUrl({
+      invoiceId,
+      userDid,
+      locale,
+    });
+
+    const billingAmount = `${fromUnitToToken(invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+
+    const shouldPayTotal = await getInvoiceShouldPayTotal(invoice);
+    if (shouldPayTotal === invoice.total) {
+      throw new Error('should pay total is equal to invoice total, no need to send billing discrepancy notification');
+    }
+    const shouldPayAmount = `${fromUnitToToken(shouldPayTotal, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
+    return {
+      userDid,
+      locale,
+      productName,
+      subscriptionId: subscription.id,
+      billingAmount,
+      shouldPayAmount,
+      invoiceId,
+      currentPeriodStart,
+      currentPeriodEnd,
+      duration,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      subscriptionId,
+      billingAmount,
+      currentPeriodStart,
+      currentPeriodEnd,
+      duration,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      shouldPayAmount,
+    } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: translate('notification.billingDiscrepancy.title', locale, {
+        productName,
+      }),
+      body: translate('notification.billingDiscrepancy.body', locale, {
+        productName,
+      }),
+      attachments: [
+        {
+          type: 'section',
+          fields: [
+            {
+              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.common.subscriptionId', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: subscriptionId,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.shouldPayAmount', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: shouldPayAmount,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.billedAmount', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: billingAmount,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.validityPeriod', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: `${currentPeriodStart} ~ ${currentPeriodEnd}(${duration})`,
+              },
+            },
+          ].filter(Boolean),
+        },
+      ],
+      actions: [
+        {
+          name: translate('notification.common.viewSubscription', locale),
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        {
+          name: translate('notification.common.viewInvoice', locale),
+          title: translate('notification.common.viewInvoice', locale),
+          link: viewInvoiceLink,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

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

@@ -12,6 +12,7 @@ import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl, getSubscriptionStakeCancellation } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { getSubscriptionNotificationCustomActions } from '../../util';
 
 export interface SubscriptionCanceledEmailTemplateOptions {
   subscriptionId: string;
@@ -31,6 +32,7 @@ interface SubscriptionCanceledEmailTemplateContext {
   cancellationReason: string;
 
   viewSubscriptionLink: string;
+  customActions: any[];
 }
 
 export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<SubscriptionCanceledEmailTemplateContext> {
@@ -128,6 +130,12 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       userDid,
     });
 
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'customer.subscription.deleted',
+      locale
+    );
+
     return {
       locale,
       productName,
@@ -142,6 +150,7 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       cancellationReason,
 
       viewSubscriptionLink,
+      customActions,
     };
   }
 
@@ -159,6 +168,7 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       cancellationReason,
 
       viewSubscriptionLink,
+      customActions,
     } = await this.getContext();
 
     const template: BaseEmailTemplateType = {
@@ -259,6 +269,7 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
           title: translate('notification.common.viewSubscription', locale),
           link: viewSubscriptionLink,
         },
+        ...customActions,
       ].filter(Boolean),
     };
 

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

@@ -5,13 +5,13 @@ import prettyMsI18n from 'pretty-ms-i18n';
 
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
-import { Customer, PaymentIntent, PaymentMethod, Refund } from '../../../store/models';
+import { Customer, PaymentIntent, PaymentMethod, Refund, Subscription } from '../../../store/models';
 import { Invoice } from '../../../store/models/invoice';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
-import { getExplorerLink } from '../../util';
+import { getExplorerLink, getSubscriptionNotificationCustomActions } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionRefundSucceededEmailTemplateOptions {
@@ -37,6 +37,7 @@ interface SubscriptionRefundSucceededEmailTemplateContext {
   viewSubscriptionLink: string;
   viewTxHashLink: string | undefined;
   refund: Refund;
+  customActions: any[];
 }
 
 export class SubscriptionRefundSucceededEmailTemplate
@@ -122,6 +123,12 @@ export class SubscriptionRefundSucceededEmailTemplate
         chainHost,
       });
 
+    let customActions: any[] = [];
+    if (refund?.subscription_id) {
+      const subscription = await Subscription.findByPk(refund.subscription_id);
+      customActions = getSubscriptionNotificationCustomActions(subscription!, 'refund.succeeded', locale);
+    }
+
     return {
       locale,
       productName,
@@ -141,6 +148,7 @@ export class SubscriptionRefundSucceededEmailTemplate
       viewSubscriptionLink,
       viewTxHashLink,
       refund,
+      customActions,
     };
   }
 

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

@@ -21,7 +21,7 @@ import { SufficientForPaymentResult, getPaymentDetail } from '../../payment';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
-import { getExplorerLink } from '../../util';
+import { getExplorerLink, getSubscriptionNotificationCustomActions } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionRenewFailedEmailTemplateOptions {
@@ -45,6 +45,7 @@ interface SubscriptionRenewFailedEmailTemplateContext {
   viewSubscriptionLink: string;
   viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
+  customActions: any[];
 }
 
 export class SubscriptionRenewFailedEmailTemplate
@@ -147,7 +148,11 @@ export class SubscriptionRenewFailedEmailTemplate
             chainHost,
           })
         : undefined;
-
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'customer.subscription.renew_failed',
+      locale
+    );
     return {
       locale,
       productName,
@@ -164,6 +169,7 @@ export class SubscriptionRenewFailedEmailTemplate
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      customActions,
     };
   }
 
@@ -182,6 +188,7 @@ export class SubscriptionRenewFailedEmailTemplate
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      customActions,
     } = await this.getContext();
 
     const template: BaseEmailTemplateType = {
@@ -308,6 +315,7 @@ export class SubscriptionRenewFailedEmailTemplate
           title: translate('notification.common.viewTxHash', locale),
           link: viewTxHashLink as string,
         },
+        ...customActions,
       ].filter(Boolean),
     };
 

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

@@ -19,7 +19,7 @@ import { getCustomerInvoicePageUrl } from '../../invoice';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
-import { getExplorerLink } from '../../util';
+import { getExplorerLink, getSubscriptionNotificationCustomActions } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionRenewedEmailTemplateOptions {
@@ -49,6 +49,7 @@ interface SubscriptionRenewedEmailTemplateContext {
   viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
   invoice: Invoice;
+  customActions: any[];
 }
 
 export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<SubscriptionRenewedEmailTemplateContext> {
@@ -93,7 +94,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
-    const at: string = formatTime(Date.now());
+    const at: string = formatTime((invoice?.status_transitions?.paid_at ?? Math.floor(Date.now() / 1000)) * 1000);
 
     const hasNft: boolean = checkoutSession?.nft_mint_status === 'minted';
     const nftMintItem: NftMintItem | undefined = hasNft
@@ -133,7 +134,11 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
             chainHost,
           })
         : undefined;
-
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'customer.subscription.renewed',
+      locale
+    );
     return {
       locale,
       productName,
@@ -151,6 +156,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
       viewInvoiceLink,
       viewTxHashLink,
       invoice,
+      customActions,
     };
   }
 
@@ -170,6 +176,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
       viewInvoiceLink,
       viewTxHashLink,
       invoice,
+      customActions,
     } = await this.getContext();
 
     if (invoice.total === '0') {
@@ -288,6 +295,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
           title: translate('notification.common.viewTxHash', locale),
           link: viewTxHashLink as string,
         },
+        ...customActions,
       ].filter(Boolean),
     };
 

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

@@ -8,7 +8,7 @@ import { PaymentCurrency } from '../../../store/models/payment-currency';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime } from '../../time';
-import { getExplorerLink } from '../../util';
+import { getExplorerLink, getSubscriptionNotificationCustomActions } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 import logger from '../../logger';
 
@@ -29,6 +29,7 @@ interface SubscriptionStakeSlashSucceededEmailTemplateContext {
 
   viewSubscriptionLink: string;
   viewTxHashLink: string | undefined;
+  customActions: any[];
 }
 
 export class SubscriptionStakeSlashSucceededEmailTemplate
@@ -105,6 +106,12 @@ export class SubscriptionStakeSlashSucceededEmailTemplate
 
     const slashReason = subscription?.cancelation_details?.slash_reason || 'admin slash';
 
+    const customActions = getSubscriptionNotificationCustomActions(
+      subscription,
+      'subscription.stake.slash.succeeded',
+      locale
+    );
+
     return {
       locale,
       productName,
@@ -115,6 +122,7 @@ export class SubscriptionStakeSlashSucceededEmailTemplate
       slashReason,
       viewSubscriptionLink,
       viewTxHashLink,
+      customActions,
     };
   }
 
@@ -129,6 +137,7 @@ export class SubscriptionStakeSlashSucceededEmailTemplate
       slashReason,
       viewSubscriptionLink,
       viewTxHashLink,
+      customActions,
     } = await this.getContext();
 
     logger.info('SubscriptionStakeSlashSucceededEmailTemplate getTemplate', { productName, at, userDid, slashInfo, viewSubscriptionLink, viewTxHashLink });
@@ -220,6 +229,7 @@ export class SubscriptionStakeSlashSucceededEmailTemplate
           title: translate('notification.common.viewTxHash', locale),
           link: viewTxHashLink as string,
         },
+        ...customActions,
       ].filter(Boolean),
     };