payment-kit 1.18.29 → 1.18.31

package/api/src/libs/setting.ts

@@ -0,0 +1,172 @@
+import { Op } from 'sequelize';
+import { CheckoutSession, Invoice, Setting, Subscription } from '../store/models';
+import type { EventType, NotificationSetting } from '../store/models/types';
+import logger from './logger';
+
+const notificationSettingKey = 'notification_settings';
+const settingIdKey = 'setting_id';
+
+export const getSettingForNotification = async (settingKey: string | null): Promise<NotificationSetting | null> => {
+  if (!settingKey) {
+    return null;
+  }
+  try {
+    const setting = await Setting.findOne({
+      where: {
+        type: 'notification',
+        [Op.or]: [
+          {
+            id: settingKey,
+          },
+          {
+            component_did: settingKey,
+          },
+          {
+            mount_location: settingKey,
+          },
+        ],
+      },
+    });
+    return (setting?.settings || null) as NotificationSetting | null;
+  } catch (error) {
+    logger.error('getSettingForNotification error', error);
+    return null;
+  }
+};
+
+export function getDirectNotificationSetting(obj: {
+  metadata?: Record<string, any>;
+  subscription_data?: Record<string, any>;
+}): NotificationSetting | null {
+  if (obj?.metadata?.[notificationSettingKey]) {
+    return obj.metadata[notificationSettingKey];
+  }
+
+  if (obj?.subscription_data?.[notificationSettingKey]) {
+    return obj.subscription_data[notificationSettingKey];
+  }
+
+  return null;
+}
+
+export function getSettingIdFromObject(obj: { metadata?: Record<string, any> }): string | null {
+  return obj?.metadata?.[settingIdKey] || null;
+}
+
+export async function getNotificationSettingFromSubscription(
+  subscription: Subscription
+): Promise<NotificationSetting | null> {
+  if (!subscription) {
+    return null;
+  }
+  const directSetting = getDirectNotificationSetting(subscription);
+  if (directSetting) {
+    return directSetting;
+  }
+
+  const settingId = getSettingIdFromObject(subscription);
+  if (settingId) {
+    return getSettingForNotification(settingId);
+  }
+
+  const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
+  return checkoutSession ? getNotificationSettingFromCheckoutSession(checkoutSession) : null;
+}
+
+export async function getNotificationSettingFromCheckoutSession(
+  checkoutSession: CheckoutSession
+): Promise<NotificationSetting | null> {
+  if (!checkoutSession) {
+    return null;
+  }
+  const directSetting = getDirectNotificationSetting(checkoutSession);
+  if (directSetting) {
+    return directSetting;
+  }
+  const settingId = getSettingIdFromObject(checkoutSession);
+  if (settingId) {
+    const settings = await getSettingForNotification(settingId);
+    return settings || null;
+  }
+  return null;
+}
+
+export async function getNotificationSettingFromInvoice(invoice: Invoice): Promise<NotificationSetting | null> {
+  if (!invoice) {
+    return null;
+  }
+  const directSetting = getDirectNotificationSetting(invoice);
+  if (directSetting) {
+    return directSetting;
+  }
+
+  const settingId = getSettingIdFromObject(invoice);
+  if (settingId) {
+    return getSettingForNotification(settingId);
+  }
+
+  if (invoice.subscription_id) {
+    const subscription = await Subscription.findByPk(invoice.subscription_id);
+    if (subscription) {
+      return getNotificationSettingFromSubscription(subscription);
+    }
+  }
+
+  if (invoice.checkout_session_id) {
+    const checkoutSession = await CheckoutSession.findByPk(invoice.checkout_session_id);
+    if (checkoutSession) {
+      return getNotificationSettingFromCheckoutSession(checkoutSession);
+    }
+  }
+  return null;
+}
+
+export type NotificationSettingsProps = {
+  subscription?: Subscription;
+  invoice?: Invoice;
+  checkoutSession?: CheckoutSession;
+};
+export async function getNotificationSettings({
+  subscription,
+  invoice,
+  checkoutSession,
+}: NotificationSettingsProps): Promise<NotificationSetting | null> {
+  if (subscription) {
+    const settings = await getNotificationSettingFromSubscription(subscription);
+    return settings || null;
+  }
+
+  if (checkoutSession) {
+    const settings = await getNotificationSettingFromCheckoutSession(checkoutSession);
+    return settings || null;
+  }
+
+  if (invoice) {
+    const settings = await getNotificationSettingFromInvoice(invoice);
+    return settings || null;
+  }
+
+  return null;
+}
+
+export function shouldSendSystemNotification(eventType: string, settings?: NotificationSetting | null): boolean {
+  if (!settings) {
+    return true;
+  }
+
+  const { include_events: includeEvents, exclude_events: excludeEvents, self_handle: selfHandle } = settings;
+  if (!selfHandle) {
+    // if self_handle is false, then the notification is sent by the system
+    return true;
+  }
+  if (includeEvents && includeEvents.length > 0) {
+    const isIncluded = includeEvents.includes(eventType as EventType);
+    return !isIncluded;
+  }
+
+  if (excludeEvents && excludeEvents.length > 0) {
+    const isExcluded = excludeEvents.includes(eventType as EventType);
+    return isExcluded;
+  }
+  return !selfHandle;
+}

package/api/src/libs/subscription.ts

@@ -30,7 +30,12 @@ import { createEvent } from './audit';
 import dayjs from './dayjs';
 import env from './env';
 import logger from './logger';
-import { getPriceCurrencyOptions, getPriceUintAmountByCurrency, getRecurringPeriod } from './session';
+import {
+  getPriceCurrencyOptions,
+  getPriceUintAmountByCurrency,
+  getRecurringPeriod,
+  getSubscriptionCreateSetup,
+} from './session';
 import { getConnectQueryParam, getCustomerStakeAddress } from './util';
 import { wallet } from './auth';
 import { getGasPayerExtra } from './payment';
@@ -184,66 +189,6 @@ export function getSubscriptionStakeSetup(items: TLineItemExpanded[], currencyId
   return staking;
 }
 
-export function getSubscriptionCreateSetup(
-  items: TLineItemExpanded[],
-  currencyId: string,
-  trialInDays = 0,
-  trialEnd = 0
-) {
-  let setup = new BN(0);
-
-  items.forEach((x) => {
-    const price = getSubscriptionItemPrice(x);
-    const unit = getPriceUintAmountByCurrency(price, currencyId);
-    const amount = new BN(unit).mul(new BN(x.quantity));
-    if (price.type === 'recurring') {
-      if (price.recurring?.usage_type === 'licensed') {
-        setup = setup.add(amount);
-      }
-    }
-    if (price.type === 'one_time') {
-      setup = setup.add(amount);
-    }
-  });
-
-  const now = dayjs().unix();
-  const item = items.find((x) => getSubscriptionItemPrice(x).type === 'recurring');
-  const recurring = (item?.upsell_price || item?.price)?.recurring as PriceRecurring;
-  const cycle = getRecurringPeriod(recurring);
-
-  let trialStartAt = 0;
-  let trialEndAt = 0;
-  if (+trialEnd && trialEnd > now) {
-    trialStartAt = now;
-    trialEndAt = trialEnd;
-  } else if (trialInDays) {
-    trialStartAt = now;
-    trialEndAt = dayjs().add(trialInDays, 'day').unix();
-  }
-
-  const periodStart = trialStartAt || now;
-  const periodEnd = trialEndAt || dayjs().add(cycle, 'millisecond').unix();
-
-  return {
-    recurring,
-    cycle: {
-      duration: cycle,
-      anchor: periodEnd,
-    },
-    trial: {
-      start: trialStartAt,
-      end: trialEndAt,
-    },
-    period: {
-      start: periodStart,
-      end: periodEnd,
-    },
-    amount: {
-      setup: setup.toString(),
-    },
-  };
-}
-
 export function getSubscriptionCycleSetup(recurring: PriceRecurring, previousPeriodEnd: number) {
   const cycle = getRecurringPeriod(recurring);
 
@@ -262,7 +207,7 @@ export function getSubscriptionCycleAmount(items: TLineItemExpanded[], currencyI
 
   items.forEach((x) => {
     amount = amount.add(
-      new BN(getPriceUintAmountByCurrency(getSubscriptionItemPrice(x), currencyId)).mul(new BN(x.quantity))
+      new BN(getPriceUintAmountByCurrency(getSubscriptionItemPrice(x) as any, currencyId)).mul(new BN(x.quantity))
     );
   });
 
@@ -458,13 +403,6 @@ export function shouldCancelSubscription(
   return false;
 }
 
-export function formatSubscriptionProduct(items: TLineItemExpanded[], maxLength = 3) {
-  const names = items.map((x) => x.price?.product?.name).filter(Boolean);
-  return (
-    names.slice(0, maxLength).join(', ') + (names.length > maxLength ? ` and ${names.length - maxLength} more` : '')
-  );
-}
-
 export async function canChangePaymentMethod(subscriptionId: string) {
   const item = await SubscriptionItem.findOne({ where: { subscription_id: subscriptionId } });
   const expanded = await Price.findOne({ where: { id: item!.price_id } });

package/api/src/libs/ws.ts

@@ -88,4 +88,9 @@ export function initEventBroadcast() {
   events.on('customer.subscription.trial_end', (data: Subscription, extraParams?: Record<string, any>) => {
     broadcast('customer.subscription.trial_end', data, extraParams);
   });
+
+  // notification events
+  events.on('manual.notification', (data: Record<string, any>) => {
+    broadcast('manual.notification', data);
+  });
 }

package/api/src/queues/checkout-session.ts

@@ -20,6 +20,7 @@ import {
   Subscription,
   SubscriptionItem,
 } from '../store/models';
+import { getCheckoutSessionSubscriptionIds } from '../libs/session';
 
 type CheckoutSessionJob = {
   id: string;
@@ -194,44 +195,49 @@ events.on('checkout.session.expired', async (checkoutSession: CheckoutSession) =
     });
   }
 
-  if (checkoutSession.subscription_id) {
-    const subscription = await Subscription.findByPk(checkoutSession.subscription_id);
-    const stripeSubscriptionId = subscription?.payment_details?.stripe?.subscription_id;
-    if (subscription && stripeSubscriptionId) {
-      const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
-      if (method?.type === 'stripe') {
-        const client = method.getStripeClient();
-        try {
-          await client.subscriptions.cancel(stripeSubscriptionId, {
-            prorate: false,
-            invoice_now: false,
-            cancellation_details: {
-              comment: 'checkout_session_expired',
-              feedback: 'unused',
-            },
-          });
-          logger.info('Stripe Subscription for checkout session canceled on expire', {
-            checkoutSession: checkoutSession.id,
-            subscription: checkoutSession.subscription_id,
-            stripeSubscription: stripeSubscriptionId,
-          });
-        } catch (err) {
-          logger.error('Stripe Subscription for checkout session cancel failed on expire', {
-            checkoutSession: checkoutSession.id,
-            subscription: checkoutSession.subscription_id,
-            stripeSubscription: stripeSubscriptionId,
-            error: err,
-          });
+  const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+  if (subscriptionIds.length > 0) {
+    const subscriptions = await Subscription.findAll({ where: { id: { [Op.in]: subscriptionIds } } });
+    await Promise.all(
+      subscriptions.map(async (subscription) => {
+        const stripeSubscriptionId = subscription?.payment_details?.stripe?.subscription_id;
+        if (subscription && stripeSubscriptionId) {
+          const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+          if (method?.type === 'stripe') {
+            const client = method.getStripeClient();
+            try {
+              await client.subscriptions.cancel(stripeSubscriptionId, {
+                prorate: false,
+                invoice_now: false,
+                cancellation_details: {
+                  comment: 'checkout_session_expired',
+                  feedback: 'unused',
+                },
+              });
+              logger.info('Stripe Subscription for checkout session canceled on expire', {
+                checkoutSession: checkoutSession.id,
+                subscription: checkoutSession.subscription_id,
+                stripeSubscription: stripeSubscriptionId,
+              });
+            } catch (err) {
+              logger.error('Stripe Subscription for checkout session cancel failed on expire', {
+                checkoutSession: checkoutSession.id,
+                subscription: checkoutSession.subscription_id,
+                stripeSubscription: stripeSubscriptionId,
+                error: err,
+              });
+            }
+          }
         }
-      }
-    }
 
-    await SubscriptionItem.destroy({ where: { subscription_id: checkoutSession.subscription_id } });
-    await Subscription.destroy({ where: { id: checkoutSession.subscription_id } });
-    logger.info('Subscription and SubscriptionItem for checkout session deleted on expire', {
-      checkoutSession: checkoutSession.id,
-      subscription: checkoutSession.subscription_id,
-    });
+        await SubscriptionItem.destroy({ where: { subscription_id: subscription.id } });
+        await Subscription.destroy({ where: { id: subscription.id } });
+        logger.info('Subscription and SubscriptionItem for checkout session deleted on expire', {
+          checkoutSession: checkoutSession.id,
+          subscription: subscription.id,
+        });
+      })
+    );
   }
 
   // update price lock status

package/api/src/queues/notification.ts

@@ -235,7 +235,8 @@ function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
 async function handleNotificationJob(job: NotificationQueueJob): Promise<void> {
   try {
     const template = getNotificationTemplate(job);
-    await new Notification(template).send();
+
+    await new Notification(template, job.type).send();
     logger.info('handleImmediateNotificationJob.success', { job });
   } catch (error) {
     logger.error('handleImmediateNotificationJob.error', error);
@@ -384,7 +385,7 @@ function getAggregatedNotificationTemplate(job: AggregatedNotificationJob): Base
 async function handleAggregatedNotificationJob(job: AggregatedNotificationJob): Promise<void> {
   try {
     const template = await getAggregatedNotificationTemplate(job);
-    await new Notification(template).send();
+    await new Notification(template, job.type).send();
     logger.info('handleAggregatedNotificationJob.success', { job });
   } catch (error) {
     logger.error('handleAggregatedNotificationJob.error', error);

package/api/src/queues/payment.ts

@@ -1,6 +1,7 @@
 import isEmpty from 'lodash/isEmpty';
 
 import { BN } from '@ocap/util';
+import pAll from 'p-all';
 import { ensureStakedForGas } from '../integrations/arcblock/stake';
 import { transferErc20FromUser } from '../integrations/ethereum/token';
 import { createEvent } from '../libs/audit';
@@ -17,7 +18,6 @@ import {
   getDueUnit,
   getMaxRetryCount,
   getMinRetryMail,
-  getSubscriptionCreateSetup,
   getSubscriptionStakeAddress,
   isSubscriptionOverdraftProtectionEnabled,
   shouldCancelSubscription,
@@ -39,7 +39,8 @@ import { ensureOverdraftProtectionInvoiceAndItems } from '../libs/invoice';
 import { Lock } from '../store/models';
 import { ensureOverdraftProtectionPrice } from '../libs/overdraft-protection';
 import createQueue from '../libs/queue';
-import { EVM_CHAIN_TYPES } from '../libs/constants';
+import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from '../libs/constants';
+import { getCheckoutSessionSubscriptionIds, getSubscriptionCreateSetup } from '../libs/session';
 
 type PaymentJob = {
   paymentIntentId: string;
@@ -231,6 +232,19 @@ export const handlePaymentSucceed = async (
         if (isEmpty(result)) {
           // reset billing cycle anchor and cancel_* if we are recovering from payment failed
           if (subscription.cancel_at && subscription.cancel_at !== subscription.current_period_end) {
+            const now = dayjs().unix();
+            if (now <= subscription.current_period_end) {
+              // if payment succeeds before current_period_end, we should active this subscription
+              await subscription.update({
+                status: 'active',
+                cancel_at: 0,
+                cancel_at_period_end: false,
+                // @ts-ignore
+                cancelation_details: null,
+              });
+              logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel rest`);
+              return;
+            }
             const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
             const lineItems = await Price.expand(subscriptionItems.map((x) => x.toJSON()));
             const setup = getSubscriptionCreateSetup(lineItems, subscription.currency_id, 0);
@@ -287,11 +301,24 @@ export const handlePaymentSucceed = async (
           checkoutSessionId: checkoutSession.id,
         });
       });
-      await checkoutSession.update({
-        status: 'complete',
-        payment_status: 'paid',
-        payment_details: paymentIntent.payment_details,
-      });
+      if (['subscription', 'setup'].includes(checkoutSession.mode) && invoice.subscription_id) {
+        await checkoutSession.increment('success_subscription_count', { by: 1 });
+        await checkoutSession.reload();
+        const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+        if (checkoutSession.success_subscription_count === subscriptionIds.length) {
+          await checkoutSession.update({
+            status: 'complete',
+            payment_status: 'paid',
+            payment_details: paymentIntent.payment_details,
+          });
+        }
+      } else {
+        await checkoutSession.update({
+          status: 'complete',
+          payment_status: 'paid',
+          payment_details: paymentIntent.payment_details,
+        });
+      }
       logger.info(`CheckoutSession ${checkoutSession.id} updated on payment done ${paymentIntent.id}`);
     }
   }
@@ -509,6 +536,7 @@ export const handlePaymentFailed = async (
       logger.warn('Subscription moved to past_due after payment failed', {
         subscription: subscription.id,
         payment: paymentIntent.id,
+        cancelUpdates,
         gracePeriodStart,
         graceDuration,
         dueUnit,
@@ -802,14 +830,16 @@ export const handlePayment = async (job: PaymentJob) => {
         wallet,
         delegator: result.delegator,
       });
+      logger.info('PaymentIntent signed', { signed });
       // @ts-ignore
       const { buffer } = await client.encodeTransferV2Tx({ tx: signed });
+      logger.info('PaymentIntent buffer', { buffer, gas: getGasPayerExtra(buffer) });
       const txHash = await client.sendTransferV2Tx(
         // @ts-ignore
         { tx: signed, wallet, delegator: result.delegator },
         getGasPayerExtra(buffer)
       );
-
+      logger.info('PaymentIntent txHash', { txHash });
       logger.info('PaymentIntent capture done', { id: paymentIntent.id, txHash });
 
       await paymentIntent.update({
@@ -1022,3 +1052,21 @@ events.on('payment.queued', async (id, job, args = {}) => {
     events.emit('payment.queued.error', { id, job, error });
   }
 });
+
+export async function startDepositVaultQueue() {
+  logger.debug('startDepositVaultQueue');
+  const paymentCurrencies = (await PaymentCurrency.scope('withVaultConfig').findAll({
+    include: [{ model: PaymentMethod, as: 'payment_method' }],
+  })) as (PaymentCurrency & { payment_method: PaymentMethod })[];
+  await pAll(
+    paymentCurrencies.map((x) => {
+      if (CHARGE_SUPPORTED_CHAIN_TYPES.includes(x.payment_method.type) && x.vault_config?.enabled === true) {
+        depositVaultQueue.push({ id: `deposit-vault-${x.id}`, job: { currencyId: x.id } });
+      }
+      return async () => {};
+    }),
+    {
+      concurrency: 5,
+    }
+  );
+}

package/api/src/queues/usage-record.ts

@@ -5,15 +5,7 @@ import { getLock } from '../libs/lock';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
 import { getPriceUintAmountByCurrency } from '../libs/session';
-import {
-  Invoice,
-  PaymentCurrency,
-  Price,
-  SubscriptionItem,
-  TLineItemExpanded,
-  TPrice,
-  UsageRecord,
-} from '../store/models';
+import { Invoice, PaymentCurrency, Price, SubscriptionItem, TLineItemExpanded, UsageRecord } from '../store/models';
 import { Subscription } from '../store/models/subscription';
 import { invoiceQueue } from './invoice';
 import { handleSubscriptionInvoice } from './subscription';
@@ -103,7 +95,7 @@ export const doHandleUsageRecord = async (job: UsageRecordJob) => {
   });
   // @ts-ignore
   const quantity = expanded?.price.transformQuantity(rawQuantity);
-  const unitAmount = getPriceUintAmountByCurrency(expanded?.price as TPrice, subscription.currency_id);
+  const unitAmount = expanded?.price ? getPriceUintAmountByCurrency(expanded?.price, subscription.currency_id) : 0;
   const totalAmount = new BN(quantity).mul(new BN(unitAmount));
   const threshold = fromTokenToUnit(subscription.billing_thresholds.amount_gte, currency.decimal);
   logger.info('SubscriptionItem Usage check', {