payment-kit 1.16.16 → 1.16.18

package/api/src/libs/notification/template/subscription.overdraft-protection.exhausted.ts

@@ -0,0 +1,139 @@
+/* eslint-disable prettier/prettier */
+import { translate } from '../../../locales';
+import { Customer, Subscription } from '../../../store/models';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { getCustomerSubscriptionPageUrl, isSubscriptionOverdraftProtectionEnabled } from '../../subscription';
+import { getMainProductName } from '../../product';
+
+export interface OverdraftProtectionExhaustedEmailTemplateOptions {
+  subscriptionId: string;
+}
+
+interface OverdraftProtectionExhaustedEmailTemplateContext {
+  locale: string;
+  userDid: string;
+  viewSubscriptionLink: string;
+  productName: string;
+  subscriptionId: string;
+}
+
+export class OverdraftProtectionExhaustedEmailTemplate
+  implements BaseEmailTemplate<OverdraftProtectionExhaustedEmailTemplateContext> {
+  options: OverdraftProtectionExhaustedEmailTemplateOptions;
+
+  constructor(options: OverdraftProtectionExhaustedEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<OverdraftProtectionExhaustedEmailTemplateContext> {
+    const { subscriptionId } = this.options;
+   
+      const subscription: Subscription | null = await Subscription.findByPk(subscriptionId);
+      if (!subscription) {
+        throw new Error(`Subscription not found: ${subscriptionId}`);
+      }
+
+      const customer: Customer | null = await Customer.findByPk(subscription.customer_id);
+      if (!customer) {
+        throw new Error(`Customer not found: ${subscription.customer_id}`);
+      }
+
+      if (!subscription.overdraft_protection?.enabled) {
+        throw new Error(`Overdraft protection not enabled for subscription: ${subscriptionId}`);
+      }
+
+     const { enabled } = await isSubscriptionOverdraftProtectionEnabled(subscription);
+     if (enabled) {
+      throw new Error(`Overdraft protection enabled for subscription: ${subscriptionId}`);
+     }
+     
+    const productName = await getMainProductName(subscription.id);
+    const userDid = customer.did;
+    const locale = await getUserLocale(userDid);
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
+      subscriptionId: subscription.id,
+      locale,
+      userDid,
+    });
+    return {
+      userDid,
+      locale,
+      viewSubscriptionLink,
+      productName,
+      subscriptionId,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const { locale, userDid, viewSubscriptionLink, productName, subscriptionId } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: translate('notification.overdraftProtectionExhausted.title', locale),
+      body: translate('notification.overdraftProtectionExhausted.body', locale, {
+        productName
+      }),
+      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.common.subscriptionId', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: subscriptionId,
+              },
+            },
+          ].filter(Boolean),
+        },
+      ],
+      actions: [
+        {
+          name: translate('notification.common.viewSubscription', locale),
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}

package/api/src/libs/overdraft-protection.ts

@@ -0,0 +1,85 @@
+import { createProductAndPrices } from '../routes/products';
+import { PaymentCurrency, PaymentMethod, Price, Product } from '../store/models';
+import logger from './logger';
+
+export const overdraftProtectionKey = 'overdraft-protection';
+
+export async function ensureOverdraftProtectionPrice(livemode = true) {
+  try {
+    const exist = await Price.findOne({ where: { lookup_key: overdraftProtectionKey, livemode } });
+    if (exist) {
+      const product = await Product.findByPk(exist.product_id);
+      return {
+        product,
+        price: exist,
+      };
+    }
+    const baseCurrency = await PaymentCurrency.findOne({ where: { is_base_currency: true, livemode } });
+    const currencies = (await PaymentCurrency.findAll({
+      where: { livemode },
+      include: [{ model: PaymentMethod, as: 'payment_method' }],
+    })) as (PaymentCurrency & { payment_method: PaymentMethod })[];
+
+    const currencyOptions = currencies
+      .filter((currency) => currency.payment_method?.type === 'arcblock')
+      .map((currency) => ({ currency_id: currency.id, unit_amount: '1' }));
+
+    const result = await createProductAndPrices({
+      type: 'service',
+      name: 'Overdraft Protection',
+      description:
+        'If you purchase this service, the overdue subscription will be protected and not be ended due to overdue',
+      images: [],
+      statement_descriptor: '',
+      unit_label: '',
+      features: [],
+      livemode,
+      prices: [
+        {
+          livemode,
+          locked: true,
+          model: 'standard',
+          billing_scheme: '',
+          currency_id: baseCurrency?.id,
+          nickname: '',
+          type: 'one_time',
+          unit_amount: '1',
+          lookup_key: overdraftProtectionKey,
+          recurring: {},
+          transform_quantity: { divide_by: 1, round: 'up' },
+          tiers: [],
+          metadata: [],
+          custom_unit_amount: null,
+          currency_options: currencyOptions,
+          tiers_mode: null,
+          quantity_available: 0,
+          quantity_limit_per_checkout: 0,
+        },
+      ],
+      metadata: [],
+    });
+    logger.info('overdraft protection price created', {
+      productId: result.id,
+      priceId: result.prices?.[0]?.id,
+    });
+    return {
+      product: result,
+      price: result.prices?.[0],
+    };
+  } catch (err) {
+    logger.error('create overdraft protection price error', err);
+    return {
+      product: null,
+      price: null,
+    };
+  }
+}
+
+export async function ensureCreateOverdraftProtectionPrices() {
+  try {
+    await ensureOverdraftProtectionPrice(true);
+    await ensureOverdraftProtectionPrice(false);
+  } catch (err) {
+    logger.error('ensure overdraft protection prices error', err);
+  }
+}

package/api/src/libs/payment.ts

@@ -10,23 +10,11 @@ import cloneDeep from 'lodash/cloneDeep';
 import type { LiteralUnion } from 'type-fest';
 
 import { fetchErc20Allowance, fetchErc20Balance, fetchEtherBalance } from '../integrations/ethereum/token';
-import {
-  Invoice,
-  PaymentCurrency,
-  PaymentIntent,
-  PaymentMethod,
-  SubscriptionItem,
-  TCustomer,
-  TLineItemExpanded,
-  Subscription,
-  Price,
-  UsageRecord,
-} from '../store/models';
+import { Invoice, PaymentCurrency, PaymentIntent, PaymentMethod, TCustomer, TLineItemExpanded } from '../store/models';
 import type { TPaymentCurrency } from '../store/models/payment-currency';
 import { blocklet, ethWallet, wallet } from './auth';
 import logger from './logger';
 import { OCAP_PAYMENT_TX_TYPE } from './util';
-import { getSubscriptionCycleAmount, getSubscriptionCycleSetup } from './subscription';
 
 export interface SufficientForPaymentResult {
   sufficient: boolean;
@@ -356,55 +344,3 @@ export async function isBalanceSufficientForRefund(args: {
 
   throw new Error(`isBalanceSufficientForRefund: Payment method ${paymentMethod.type} not supported`);
 }
-
-export async function getPaymentAmountForCycleSubscription(
-  subscription: Subscription,
-  paymentCurrency: PaymentCurrency
-) {
-  const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
-  if (subscriptionItems.length === 0) {
-    logger.info('subscription items not found in getPaymentAmountForCycleSubscription', {
-      subscription: subscription.id,
-    });
-    return 0;
-  }
-  let expandedItems = await Price.expand(
-    subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
-    { product: true }
-  );
-  if (expandedItems.length === 0) {
-    logger.info('expanded items not found in getPaymentAmountForCycleSubscription', {
-      subscription: subscription.id,
-    });
-    return 0;
-  }
-  const previousPeriodEnd =
-    subscription.status === 'trialing' ? subscription.trial_end : subscription.current_period_end;
-  const setup = getSubscriptionCycleSetup(subscription.pending_invoice_item_interval, previousPeriodEnd as number);
-  // get usage summaries for this billing cycle
-  expandedItems = await Promise.all(
-    expandedItems.map(async (x: any) => {
-      // For metered billing, we need to get usage summary for this billing cycle
-      // @link https://stripe.com/docs/products-prices/pricing-models#usage-types
-      if (x.price.recurring?.usage_type === 'metered') {
-        const rawQuantity = await UsageRecord.getSummary({
-          id: x.id,
-          start: setup.period.start - setup.cycle / 1000,
-          end: setup.period.end - setup.cycle / 1000,
-          method: x.price.recurring?.aggregate_usage,
-          dryRun: true,
-        });
-        x.quantity = x.price.transformQuantity(rawQuantity);
-        // record raw quantity in metadata
-        x.metadata = x.metadata || {};
-        x.metadata.quantity = rawQuantity;
-      }
-      return x;
-    })
-  );
-  if (expandedItems.length > 0) {
-    const amount = getSubscriptionCycleAmount(expandedItems, paymentCurrency.id);
-    return +fromUnitToToken(amount?.total || '0', paymentCurrency.decimal);
-  }
-  return 0;
-}

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

@@ -147,7 +147,6 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
         })
         .catch((err) => {
           console.error(err);
-          logger.error('Can not add scheduled job to store', { jobId, job, attrs, error: err });
         });
 
       // @ts-ignore