payment-kit 1.18.25 → 1.18.27

package/api/src/queues/notification.ts

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/indent */
+import { Op } from 'sequelize';
 import { events } from '../libs/event';
 import logger from '../libs/logger';
+import dayjs from '../libs/dayjs';
 import { Notification } from '../libs/notification';
 import type { BaseEmailTemplate } from '../libs/notification/template/base';
 import {
@@ -56,7 +58,16 @@ import {
   SubscriptionStakeSlashSucceededEmailTemplateOptions,
 } from '../libs/notification/template/subscription-stake-slash-succeeded';
 import createQueue from '../libs/queue';
-import { CheckoutSession, EventType, Invoice, PaymentLink, Payout, Refund, Subscription } from '../store/models';
+import {
+  CheckoutSession,
+  EventType,
+  Invoice,
+  PaymentLink,
+  Payout,
+  Refund,
+  Subscription,
+  Customer,
+} from '../store/models';
 import {
   UsageReportEmptyEmailTemplate,
   UsageReportEmptyEmailTemplateOptions,
@@ -73,9 +84,22 @@ import {
   CustomerRevenueSucceededEmailTemplate,
   CustomerRevenueSucceededEmailTemplateOptions,
 } from '../libs/notification/template/customer-revenue-succeeded';
+import {
+  AggregatedSubscriptionRenewedEmailTemplate,
+  AggregatedSubscriptionRenewedEmailTemplateOptions,
+} from '../libs/notification/template/aggregated-subscription-renewed';
+import type { TJob } from '../store/models/job';
 
 export type NotificationQueueJobOptions = any;
 
+interface NotificationPreference {
+  frequency: 'default' | 'daily' | 'weekly' | 'monthly';
+  schedule?: {
+    time: string; // HH:mm 格式
+    date?: number; // weekly: 0-6, monthly: 1-31
+  };
+}
+
 export type NotificationQueueJobType =
   | EventType
   | 'customer.subscription.will_renew'
@@ -91,6 +115,62 @@ export type NotificationQueueJob = {
   options: NotificationQueueJobOptions;
 };
 
+export interface AggregatedNotificationJob {
+  type: NotificationQueueJobType;
+  options: {
+    customer_id: string;
+    items: NotificationItem[];
+    time_range: {
+      start: number;
+      end: number;
+    };
+  };
+}
+
+function calculateNextNotificationTime(preference: NotificationPreference): number {
+  if (preference.frequency === 'default' || !preference.schedule) {
+    return Math.floor(Date.now() / 1000);
+  }
+
+  const now = dayjs();
+  const [hour = 10, minute = 0] = preference.schedule?.time ? preference.schedule.time.split(':').map(Number) : [10, 0];
+  let nextTime = dayjs().hour(hour).minute(minute).second(0);
+  const targetDate = preference.schedule?.date ?? 1;
+
+  switch (preference.frequency) {
+    case 'daily':
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'day');
+      }
+      break;
+
+    case 'weekly':
+      nextTime = nextTime.day(targetDate);
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'week');
+      }
+      break;
+
+    case 'monthly':
+      nextTime = nextTime.date(targetDate);
+      // if the date is not the same, set to the end of the month
+      if (nextTime.date() !== targetDate) {
+        nextTime = nextTime.endOf('month').hour(hour).minute(minute);
+      }
+      if (nextTime.isBefore(now)) {
+        nextTime = nextTime.add(1, 'month');
+        if (nextTime.date() !== targetDate) {
+          nextTime = nextTime.endOf('month').hour(hour).minute(minute);
+        }
+      }
+      break;
+    default:
+      throw new Error(`Unknown frequency: ${preference.frequency}`);
+  }
+
+  return Math.floor(nextTime.valueOf() / 1000);
+}
+
 function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
   if (job.type === 'usage.report.empty') {
     return new UsageReportEmptyEmailTemplate(job.options as UsageReportEmptyEmailTemplateOptions);
@@ -156,10 +236,158 @@ async function handleNotificationJob(job: NotificationQueueJob): Promise<void> {
   try {
     const template = getNotificationTemplate(job);
     await new Notification(template).send();
-    logger.info('handleNotificationJob.success', { job });
+    logger.info('handleImmediateNotificationJob.success', { job });
   } catch (error) {
-    logger.error('handleNotificationJob.error.$job', job);
-    logger.error('handleNotificationJob.error', error);
+    logger.error('handleImmediateNotificationJob.error', error);
+    throw error;
+  }
+}
+
+const MAX_AGGREGATED_ITEMS = 1000;
+
+interface NotificationItem<T = Record<string, any>> {
+  event_id: string;
+  occurred_at: number;
+  data: T;
+}
+
+/**
+ * Handles immediate notifications by pushing them directly to the notification queue
+ */
+function handleImmediateNotification(type: string, data: Record<string, any>, extraIds: string[] = []) {
+  const idParts = [type];
+  if (extraIds.length) {
+    idParts.push(...extraIds);
+  } else {
+    idParts.push(Date.now().toString());
+  }
+
+  return notificationQueue.push({
+    id: idParts.join('.'),
+    job: {
+      type,
+      options: data,
+    },
+  });
+}
+
+/**
+ * Handles aggregated notifications with support for:
+ * - Automatic fallback to immediate notification on error
+ * - Item limit enforcement
+ * - Time range tracking
+ */
+async function handleAggregatedNotification<T extends Record<string, any>>({
+  type,
+  customerId,
+  preference,
+  newItem,
+  extraIds,
+}: {
+  type: NotificationQueueJobType;
+  customerId: string;
+  preference: NotificationPreference;
+  newItem: NotificationItem<T>;
+  extraIds: string[];
+}) {
+  try {
+    const nextNotificationTime = calculateNextNotificationTime(preference);
+    const jobId = `${type}.${customerId}.${nextNotificationTime}`;
+    const existingJob = await aggregatedNotificationQueue.get(jobId);
+
+    if (existingJob) {
+      const updatedItems = [...(existingJob.options.items || []), newItem];
+
+      if (updatedItems.length >= MAX_AGGREGATED_ITEMS) {
+        await aggregatedNotificationQueue.push({
+          id: `${jobId}.immediate`,
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: existingJob.options.items,
+              time_range: {
+                start: existingJob.options.time_range.start,
+                end: Math.floor(Date.now() / 1000),
+              },
+            },
+          },
+        });
+        logger.info('immediate aggregated notification job', { jobId });
+
+        await aggregatedNotificationQueue.update(jobId, {
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: [newItem],
+              time_range: {
+                start: Math.floor(Date.now() / 1000),
+                end: nextNotificationTime,
+              },
+            },
+          },
+          runAt: nextNotificationTime,
+        });
+        logger.info('update aggregated notification job', { jobId });
+      } else {
+        await aggregatedNotificationQueue.update(jobId, {
+          job: {
+            type,
+            options: {
+              customer_id: customerId,
+              items: updatedItems,
+              time_range: {
+                start: existingJob.options.time_range.start,
+                end: nextNotificationTime,
+              },
+            },
+          },
+          runAt: nextNotificationTime,
+        });
+      }
+      logger.info('updated aggregated notification job', { jobId });
+    } else {
+      // Create new aggregation task
+      await aggregatedNotificationQueue.push({
+        id: jobId,
+        job: {
+          type,
+          options: {
+            customer_id: customerId,
+            items: [newItem],
+            time_range: {
+              start: Math.floor(Date.now() / 1000),
+              end: nextNotificationTime,
+            },
+          },
+        },
+        runAt: nextNotificationTime,
+      });
+    }
+    logger.info('created aggregated notification job', { jobId });
+  } catch (error) {
+    logger.error('Failed to handle aggregated notification', { error });
+    await handleImmediateNotification(type, newItem.data, extraIds);
+  }
+}
+
+function getAggregatedNotificationTemplate(job: AggregatedNotificationJob): BaseEmailTemplate {
+  if (job.type === 'customer.subscription.renewed') {
+    return new AggregatedSubscriptionRenewedEmailTemplate(
+      job.options as AggregatedSubscriptionRenewedEmailTemplateOptions
+    );
+  }
+  throw new Error(`Unknown aggregated notification type: ${job.type}`);
+}
+
+async function handleAggregatedNotificationJob(job: AggregatedNotificationJob): Promise<void> {
+  try {
+    const template = await getAggregatedNotificationTemplate(job);
+    await new Notification(template).send();
+    logger.info('handleAggregatedNotificationJob.success', { job });
+  } catch (error) {
+    logger.error('handleAggregatedNotificationJob.error', error);
     throw error;
   }
 }
@@ -174,6 +402,16 @@ export const notificationQueue = createQueue<NotificationQueueJob>({
   },
 });
 
+export const aggregatedNotificationQueue = createQueue<AggregatedNotificationJob>({
+  name: 'aggregated_notification',
+  onJob: handleAggregatedNotificationJob,
+  options: {
+    concurrency: 10,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
 /**
  *
  * @see https://team.arcblock.io/comment/discussions/0fba06ff-75b4-47d2-8c5c-f0379540ce03
@@ -239,16 +477,39 @@ export async function startNotificationQueue() {
     }
   });
 
-  events.on('customer.subscription.renewed', (subscription: Subscription) => {
-    notificationQueue.push({
-      id: `customer.subscription.renewed.${subscription.id}.${subscription.latest_invoice_id}`,
-      job: {
-        type: 'customer.subscription.renewed',
-        options: {
+  events.on('customer.subscription.renewed', async (subscription: Subscription) => {
+    const customer = await Customer.findByPk(subscription.customer_id);
+    const preference = customer?.preference?.notification;
+    if (!subscription.latest_invoice_id) {
+      logger.warn('Missing latest_invoice_id for subscription', { subscriptionId: subscription.id });
+      return;
+    }
+
+    if (!preference || preference.frequency === 'default') {
+      handleImmediateNotification(
+        'customer.subscription.renewed',
+        {
+          subscriptionId: subscription.id,
+          invoiceId: subscription.latest_invoice_id,
+        },
+        [subscription.id, subscription.latest_invoice_id]
+      );
+      return;
+    }
+
+    await handleAggregatedNotification({
+      type: 'customer.subscription.renewed',
+      customerId: customer.id,
+      preference,
+      newItem: {
+        event_id: `${subscription.id}.${subscription.latest_invoice_id}`,
+        occurred_at: Math.floor(Date.now() / 1000),
+        data: {
           subscriptionId: subscription.id,
           invoiceId: subscription.latest_invoice_id,
-        } as SubscriptionRenewedEmailTemplateOptions,
+        },
       },
+      extraIds: [subscription.id, subscription.latest_invoice_id],
     });
   });
 
@@ -362,3 +623,84 @@ export async function startNotificationQueue() {
     }
   });
 }
+
+export async function handleNotificationPreferenceChange(
+  customerId: string,
+  newPreference?: NotificationPreference
+): Promise<void> {
+  // 1. get pending scheduled jobs for this customer
+  const pendingJobs = await aggregatedNotificationQueue.store.findJobs({
+    delay: { [Op.not]: -1 },
+    will_run_at: { [Op.gt]: Date.now() },
+  });
+
+  const customerJobs = pendingJobs.filter((job: TJob) => job.job?.options?.customer_id === customerId);
+
+  if (!customerJobs.length) {
+    return;
+  }
+
+  // 2. if changed to immediate notification, delete the old job and create a new one immediately
+  if (newPreference?.frequency === 'default') {
+    /* eslint-disable no-await-in-loop */
+    for (const job of customerJobs) {
+      try {
+        await aggregatedNotificationQueue.delete(job.id);
+        aggregatedNotificationQueue.push({
+          id: job.id,
+          job: {
+            ...job.job,
+            options: {
+              ...job.job.options,
+              time_range: {
+                start: job.job.options.time_range.start,
+                end: Math.floor(Date.now() / 1000),
+              },
+            },
+          },
+        });
+      } catch (error) {
+        logger.error('Failed to process immediate notification job', { error, jobId: job.id });
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+    return;
+  }
+
+  // 3. for other frequency changes, recalculate the send time
+  if (newPreference) {
+    /* eslint-disable no-await-in-loop */
+    for (const job of customerJobs) {
+      try {
+        const nextTime = calculateNextNotificationTime(newPreference);
+        const oldScheduleTime = job.will_run_at ? job.will_run_at / 1000 : 0;
+
+        // if next notification time is different from the old schedule time, update the job
+        if (nextTime !== oldScheduleTime) {
+          // Keep the original job id format but update the timestamp
+          const jobIdParts = job.id.split('.');
+          const jobId = `${jobIdParts.slice(0, -1).join('.')}.${nextTime}`;
+
+          await aggregatedNotificationQueue.delete(job.id);
+          aggregatedNotificationQueue.push({
+            id: jobId,
+            job: {
+              ...job.job,
+              options: {
+                ...job.job.options,
+                time_range: {
+                  start: job.job.options.time_range.start,
+                  end: nextTime,
+                },
+              },
+            },
+            runAt: nextTime,
+          });
+        }
+      } catch (error) {
+        logger.error('Failed to process notification job', { error, jobId: job.id });
+      }
+    }
+    /* eslint-enable no-await-in-loop */
+  }
+}

package/api/src/routes/customers.ts

@@ -24,6 +24,7 @@ import {
 } from '../store/models';
 import { getSubscriptionPaymentAddress, calculateRecommendedRechargeAmount } from '../libs/subscription';
 import { expandLineItems } from '../libs/session';
+import { handleNotificationPreferenceChange } from '../queues/notification';
 
 const router = Router();
 const auth = authenticate<Customer>({ component: true, roles: ['owner', 'admin'] });
@@ -181,6 +182,9 @@ router.get('/:id/overdue/invoices', sessionMiddleware(), async (req, res) => {
     if (!doc) {
       return res.status(404).json({ error: 'Customer not found' });
     }
+    if (doc.did !== req.user.did && !['admin', 'owner'].includes(req.user?.role)) {
+      return res.status(403).json({ error: 'You are not allowed to access this customer invoices' });
+    }
     const { rows: invoices, count } = await Invoice.findAndCountAll({
       where: {
         customer_id: doc.id,
@@ -367,6 +371,63 @@ router.get('/:id/summary', auth, async (req, res) => {
   }
 });
 
+const updatePreferenceSchema = Joi.object({
+  notification: Joi.object({
+    frequency: Joi.string().valid('default', 'daily', 'weekly', 'monthly').required(),
+    schedule: Joi.object({
+      time: Joi.string().pattern(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/),
+      date: Joi.alternatives().conditional('..frequency', {
+        switch: [
+          { is: 'weekly', then: Joi.number().min(0).max(6).required() },
+          { is: 'monthly', then: Joi.number().min(1).max(31).required() },
+          { is: Joi.valid('daily', 'default'), then: Joi.number().optional() },
+        ],
+      }),
+    }).when('frequency', {
+      is: 'default',
+      then: Joi.optional(),
+      otherwise: Joi.required(),
+    }),
+  }).optional(),
+}).unknown(false);
+
+router.put('/preference', sessionMiddleware(), async (req, res) => {
+  try {
+    if (!req.user) {
+      return res.status(403).json({ error: 'Unauthorized' });
+    }
+
+    const doc = await Customer.findByPkOrDid(req.user.did as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    const { error, value } = updatePreferenceSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    // Get old preference before update
+    const oldPreference = doc.preference?.notification;
+
+    await doc.update({ preference: value });
+
+    // Handle notification queue updates if notification preference changed
+    if (
+      oldPreference?.frequency !== value.notification?.frequency ||
+      oldPreference?.schedule?.time !== value.notification?.schedule?.time ||
+      oldPreference?.schedule?.date !== value.notification?.schedule?.date
+    ) {
+      await handleNotificationPreferenceChange(doc.id, value.notification);
+    }
+
+    return res.json(doc);
+  } catch (err) {
+    logger.error('Failed to update customer preference', err);
+    return res.status(400).json({ error: `Failed to update preference: ${err.message}` });
+  }
+});
+
 const updateCustomerSchema = Joi.object({
   metadata: MetadataSchema,
   name: Joi.string().min(2).max(30).empty(''),

package/api/src/routes/subscriptions.ts

@@ -1906,7 +1906,7 @@ router.get('/:id/overdue/invoices', authPortal, async (req, res) => {
       return res.status(404).json({ error: 'Subscription not found' });
     }
     // @ts-ignore
-    if (subscription.customer?.did !== req.user?.did) {
+    if (subscription.customer?.did !== req.user?.did && !['admin', 'owner'].includes(req.user?.role)) {
       return res.status(403).json({ error: 'You are not allowed to access this subscription' });
     }
     const { rows: invoices, count } = await Invoice.findAndCountAll({

package/api/src/store/migrations/20250328-notification-preference.ts

@@ -0,0 +1,29 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    customers: [
+      {
+        name: 'preference',
+        field: {
+          type: DataTypes.JSON,
+          defaultValue: JSON.stringify({
+            notification: {
+              frequency: 'monthly',
+              schedule: {
+                time: '10:00',
+                date: 1,
+              },
+            },
+          }),
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('customers', 'preference');
+};

package/api/src/store/models/customer.ts

@@ -17,7 +17,7 @@ import { createEvent } from '../../libs/audit';
 import CustomError from '../../libs/error';
 import { getLock } from '../../libs/lock';
 import { createCodeGenerator, createIdGenerator } from '../../libs/util';
-import type { CustomerAddress, CustomerShipping } from './types';
+import type { CustomerAddress, CustomerPreferences, CustomerShipping } from './types';
 
 export const nextCustomerId = createIdGenerator('cus', 14);
 export const nextInvoicePrefix = createCodeGenerator('', 8);
@@ -65,6 +65,7 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
   declare last_sync_at?: number;
+  declare preference?: CustomerPreferences;
 
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
@@ -234,6 +235,19 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
           type: DataTypes.INTEGER,
           allowNull: true,
         },
+        preference: {
+          type: DataTypes.JSON,
+          allowNull: true,
+          defaultValue: {
+            notification: {
+              frequency: 'monthly',
+              schedule: {
+                time: '10:00',
+                date: 1,
+              },
+            },
+          },
+        },
       },
       {
         sequelize,

package/api/src/store/models/types.ts

@@ -442,7 +442,7 @@ export type PricingTableItem = {
   // Enables user redeemable promotion codes.
   allow_promotion_codes: boolean;
 
-  // Configuration for collecting the customer’s billing address.
+  // Configuration for collecting the customer's billing address.
   billing_address_collection?: LiteralUnion<'auto' | 'required', string>;
 
   is_highlight: boolean;
@@ -704,3 +704,19 @@ export type EventType = LiteralUnion<
 export type StripeRefundReason = 'duplicate' | 'fraudulent' | 'requested_by_customer';
 
 export type SettingType = LiteralUnion<'donate', string>;
+
+export type NotificationFrequency = 'default' | 'daily' | 'weekly' | 'monthly';
+export type NotificationSchedule = {
+  time: string; // HH:mm 格式
+  date?: number; // weekly: 0-6, monthly: 1-31
+};
+
+export type NotificationSettings = {
+  frequency: NotificationFrequency;
+  schedule?: NotificationSchedule;
+};
+
+export type CustomerPreferences = {
+  notification?: NotificationSettings;
+  // support more preferences
+};

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.18.25
+version: 1.18.27
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.25",
+  "version": "1.18.27",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -44,29 +44,29 @@
   },
   "dependencies": {
     "@abtnode/cron": "^1.16.41",
-    "@arcblock/did": "^1.19.15",
+    "@arcblock/did": "^1.19.19",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.12.52",
-    "@arcblock/did-util": "^1.19.15",
-    "@arcblock/jwt": "^1.19.15",
-    "@arcblock/ux": "^2.12.52",
-    "@arcblock/validator": "^1.19.15",
+    "@arcblock/did-connect": "^2.12.60",
+    "@arcblock/did-util": "^1.19.19",
+    "@arcblock/jwt": "^1.19.19",
+    "@arcblock/ux": "^2.12.60",
+    "@arcblock/validator": "^1.19.19",
     "@blocklet/js-sdk": "^1.16.41",
     "@blocklet/logger": "^1.16.41",
-    "@blocklet/payment-react": "1.18.25",
+    "@blocklet/payment-react": "1.18.27",
     "@blocklet/sdk": "^1.16.41",
-    "@blocklet/ui-react": "^2.12.52",
-    "@blocklet/uploader": "^0.1.81",
-    "@blocklet/xss": "^0.1.30",
+    "@blocklet/ui-react": "^2.12.60",
+    "@blocklet/uploader": "^0.1.82",
+    "@blocklet/xss": "^0.1.31",
     "@mui/icons-material": "^5.16.6",
     "@mui/lab": "^5.0.0-alpha.173",
     "@mui/material": "^5.16.6",
     "@mui/system": "^5.16.6",
-    "@ocap/asset": "^1.19.15",
-    "@ocap/client": "^1.19.15",
-    "@ocap/mcrypto": "^1.19.15",
-    "@ocap/util": "^1.19.15",
-    "@ocap/wallet": "^1.19.15",
+    "@ocap/asset": "^1.19.19",
+    "@ocap/client": "^1.19.19",
+    "@ocap/mcrypto": "^1.19.19",
+    "@ocap/util": "^1.19.19",
+    "@ocap/wallet": "^1.19.19",
     "@stripe/react-stripe-js": "^2.7.3",
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.0",
@@ -121,7 +121,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.41",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.25",
+    "@blocklet/payment-types": "1.18.27",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -151,7 +151,7 @@
     "vite": "^5.3.5",
     "vite-node": "^2.0.4",
     "vite-plugin-babel-import": "^2.0.5",
-    "vite-plugin-blocklet": "^0.9.29",
+    "vite-plugin-blocklet": "^0.9.31",
     "vite-plugin-node-polyfills": "^0.21.0",
     "vite-plugin-svgr": "^4.2.0",
     "vite-tsconfig-paths": "^4.3.2",
@@ -167,5 +167,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "1665ec667d621a3e607650e486cb0967371b9771"
+  "gitHead": "2bbcff1991daf5de147813c598e13d755da0c989"
 }