payment-kit 1.22.29 → 1.22.31

package/api/src/libs/util.ts

@@ -163,10 +163,10 @@ export function tryWithTimeout(asyncFn: Function, timeout = 5000) {
 }
 
 // simple exponential delay: 2^retryCount
-export const getNextRetry = (retryCount: number) => {
+export const getNextRetry = (retryCount: number, eventCreatedAt?: Date) => {
   const delay = 2 ** retryCount;
-  const now = dayjs().unix();
-  return now + delay;
+  const baseTime = eventCreatedAt ? dayjs(eventCreatedAt).unix() : dayjs().unix();
+  return baseTime + delay;
 };
 
 export const getWebhookJobId = (eventId: string, webhookId: string) => {

package/api/src/queues/event.ts

@@ -3,11 +3,10 @@ import { Op } from 'sequelize';
 import { events } from '../libs/event';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { getWebhookJobId } from '../libs/util';
 import { Event } from '../store/models/event';
 import { WebhookAttempt } from '../store/models/webhook-attempt';
 import { WebhookEndpoint } from '../store/models/webhook-endpoint';
-import { webhookQueue } from './webhook';
+import { addWebhookJob } from './webhook';
 
 type EventJob = {
   eventId: string;
@@ -52,16 +51,8 @@ export const handleEvent = async (job: EventJob) => {
 
     // we should only push webhook if it's not successfully attempted before
     if (attemptCount === 0) {
-      const jobId = getWebhookJobId(event.id, webhook.id);
-      const exist = await webhookQueue.get(jobId);
-      if (!exist) {
-        logger.info(`Scheduling attempt for event ${event.id} and webhook ${webhook.id}`, job);
-        webhookQueue.push({
-          id: jobId,
-          job: { eventId: event.id, webhookId: webhook.id },
-          persist: false,
-        });
-      }
+      logger.info(`Scheduling attempt for event ${event.id} and webhook ${webhook.id}`, job);
+      await addWebhookJob(event.id, webhook.id, { persist: false });
     }
   });
 

package/api/src/queues/webhook.ts

@@ -14,6 +14,29 @@ import { WebhookAttempt } from '../store/models/webhook-attempt';
 import { WebhookEndpoint } from '../store/models/webhook-endpoint';
 import { addNotificationJob } from './notification';
 
+async function decrementPendingWebhooks(event: Event, webhookId: string) {
+  const existingSuccessCount = await WebhookAttempt.count({
+    where: {
+      event_id: event.id,
+      webhook_endpoint_id: webhookId,
+      status: 'succeeded',
+    },
+  });
+
+  if (existingSuccessCount === 0) {
+    if (event.pending_webhooks > 0) {
+      await event.decrement('pending_webhooks');
+      logger.info('pending_webhooks decremented', { eventId: event.id, newCount: event.pending_webhooks, webhookId });
+    } else {
+      logger.warn('Attempted to decrement pending_webhooks below 0', {
+        eventId: event.id,
+        currentCount: event.pending_webhooks,
+        webhookId,
+      });
+    }
+  }
+}
+
 type WebhookJob = {
   eventId: string;
   webhookId: string;
@@ -80,8 +103,7 @@ export const handleWebhook = async (job: WebhookJob) => {
     });
     logger.info('WebhookAttempt created successfully', { eventId: event.id, webhookId: webhook.id });
 
-    await event.decrement('pending_webhooks');
-    logger.info('pending_webhooks decremented', { eventId: event.id, newCount: event.pending_webhooks });
+    await decrementPendingWebhooks(event, webhook.id);
 
     logger.info('webhook attempt success', { ...job, retryCount });
   } catch (err: any) {
@@ -110,20 +132,13 @@ export const handleWebhook = async (job: WebhookJob) => {
 
     if (retryCount < MAX_RETRY_COUNT) {
       process.nextTick(() => {
-        webhookQueue.push({
-          id: getWebhookJobId(event.id, webhook.id),
-          job: { eventId: event.id, webhookId: webhook.id },
-          runAt: getNextRetry(retryCount),
+        addWebhookJob(event.id, webhook.id, {
+          runAt: getNextRetry(retryCount, event.created_at),
           persist: false,
         });
-        logger.info('scheduled webhook job', { ...job, retryCount });
       });
     } else {
-      await event.decrement('pending_webhooks');
-      logger.info('Max retries reached, pending_webhooks decremented', {
-        eventId: event.id,
-        newCount: event.pending_webhooks,
-      });
+      await decrementPendingWebhooks(event, webhook.id);
     }
   }
 };
@@ -183,3 +198,36 @@ export const webhookQueue = createQueue<WebhookJob>({
 webhookQueue.on('failed', ({ id, job, error }) => {
   logger.error('webhook job failed', { id, job, error });
 });
+
+export async function addWebhookJob(
+  eventId: string,
+  webhookId: string,
+  options: {
+    runAt?: number;
+    persist?: boolean;
+    replace?: boolean;
+  } = {}
+) {
+  const { runAt, persist = false, replace = true } = options;
+  const jobId = getWebhookJobId(eventId, webhookId);
+  const exist = await webhookQueue.get(jobId);
+
+  if (exist && !replace) {
+    logger.info('Webhook job already exists, skipping', { eventId, webhookId, jobId });
+    return false;
+  }
+
+  if (exist) {
+    await webhookQueue.delete(jobId);
+  }
+
+  webhookQueue.push({
+    id: jobId,
+    job: { eventId, webhookId },
+    runAt,
+    persist,
+  });
+
+  logger.info('Webhook job added to queue', { eventId, webhookId, jobId, runAt, persist });
+  return true;
+}

package/api/src/routes/events.ts

@@ -1,12 +1,16 @@
 import { Router } from 'express';
 import Joi from 'joi';
 import type { WhereOptions } from 'sequelize';
+import { Op } from 'sequelize';
 
 import { createListParamSchema, getOrder } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { Event } from '../store/models/event';
 import { blocklet } from '../libs/auth';
 import logger from '../libs/logger';
+import { addWebhookJob } from '../queues/webhook';
+import { WebhookEndpoint } from '../store/models/webhook-endpoint';
+import { Subscription } from '../store/models/subscription';
 
 const router = Router();
 const auth = authenticate<Event>({ component: true, roles: ['owner', 'admin'] });
@@ -55,6 +59,157 @@ router.get('/', auth, async (req, res) => {
   }
 });
 
+const retryWebhooksSchema = createListParamSchema<{
+  eventType?: string;
+  objectType?: string;
+  objectId?: string;
+  objectIds?: string;
+  eventIds?: string;
+  subscriptionStatus?: string;
+  latestOnly?: boolean;
+}>({
+  eventType: Joi.string().empty(''),
+  objectType: Joi.string().empty(''),
+  objectId: Joi.string().empty(''),
+  objectIds: Joi.string().empty(''),
+  eventIds: Joi.string().empty(''),
+  subscriptionStatus: Joi.string().empty(''),
+  latestOnly: Joi.boolean().optional(),
+});
+
+router.get('/retry-webhooks', auth, async (req, res) => {
+  try {
+    const { eventType, objectType, objectId, objectIds, eventIds, subscriptionStatus, latestOnly } =
+      await retryWebhooksSchema.validateAsync(req.query, {
+        stripUnknown: true,
+      });
+
+    const where: WhereOptions<Event> = { livemode: req.livemode };
+    let targetObjectIds: string[] = [];
+
+    // Handle subscription status filter
+    if (subscriptionStatus) {
+      const subscriptions = await Subscription.findAll({
+        where: {
+          status: subscriptionStatus,
+          livemode: req.livemode,
+        },
+        attributes: ['id'],
+      });
+
+      if (subscriptions.length === 0) {
+        return res.json({
+          message: `No subscriptions found with status: ${subscriptionStatus}`,
+          scheduled: 0,
+          eventsProcessed: 0,
+        });
+      }
+
+      targetObjectIds = subscriptions.map((sub) => sub.id);
+      where.object_type = 'subscription';
+      where.object_id = { [Op.in]: targetObjectIds };
+
+      logger.info(`Found ${targetObjectIds.length} subscriptions with status: ${subscriptionStatus}`);
+    }
+
+    // Handle explicit object filters
+    if (objectType) {
+      where.object_type = objectType;
+    }
+
+    if (objectId) {
+      where.object_id = objectId;
+    }
+
+    if (objectIds) {
+      const ids = objectIds
+        .split(',')
+        .map((x) => x.trim())
+        .filter(Boolean);
+      where.object_id = ids.length > 1 ? { [Op.in]: ids } : ids[0];
+    }
+
+    if (eventType) {
+      where.type = eventType;
+    }
+
+    if (eventIds) {
+      const ids = eventIds
+        .split(',')
+        .map((x) => x.trim())
+        .filter(Boolean);
+      where.id = ids.length > 1 ? { [Op.in]: ids } : ids[0];
+    }
+
+    let events = await Event.findAll({
+      where,
+      order: [['created_at', 'DESC']],
+    });
+
+    if (events.length === 0) {
+      return res.json({
+        message: 'No events found matching the criteria',
+        scheduled: 0,
+        eventsProcessed: 0,
+      });
+    }
+
+    // If latestOnly is true, group by object_id and keep only the latest event for each
+    if (latestOnly) {
+      const eventsByObject = new Map<string, Event>();
+      events.forEach((event) => {
+        if (!eventsByObject.has(event.object_id)) {
+          eventsByObject.set(event.object_id, event);
+        }
+      });
+      events = Array.from(eventsByObject.values());
+      logger.info(`Filtered to ${events.length} latest events (from ${eventsByObject.size} unique objects)`);
+    }
+
+    const webhooks = await WebhookEndpoint.findAll({
+      where: { status: 'enabled', livemode: req.livemode },
+    });
+
+    if (webhooks.length === 0) {
+      return res.json({
+        message: 'No enabled webhook endpoints found',
+        scheduled: 0,
+        eventsProcessed: events.length,
+      });
+    }
+
+    let scheduled = 0;
+    // eslint-disable-next-line no-restricted-syntax
+    for (const event of events) {
+      const eventWebhooks = webhooks.filter((webhook) => webhook.enabled_events.includes(event.type));
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const webhook of eventWebhooks) {
+        // eslint-disable-next-line no-await-in-loop
+        const added = await addWebhookJob(event.id, webhook.id, { persist: false });
+        if (added) {
+          scheduled += 1;
+        }
+      }
+    }
+
+    logger.info('Batch webhook retry completed', {
+      eventsProcessed: events.length,
+      webhooksScheduled: scheduled,
+      criteria: { eventType, objectType, objectId, subscriptionStatus, latestOnly },
+    });
+
+    return res.json({
+      message: `Successfully scheduled ${scheduled} webhooks for retry across ${events.length} events`,
+      scheduled,
+      eventsProcessed: events.length,
+    });
+  } catch (err: any) {
+    logger.error('Failed to batch retry webhooks', err);
+    return res.status(500).json({ error: `Failed to retry webhooks: ${err.message}` });
+  }
+});
+
 router.get('/:id', auth, async (req, res) => {
   try {
     const doc = await Event.findOne({
@@ -77,4 +232,45 @@ router.get('/:id', auth, async (req, res) => {
   }
 });
 
+router.post('/:id/retry-webhooks', auth, async (req, res) => {
+  try {
+    const event = await Event.findOne({
+      where: { id: req.params.id },
+    });
+
+    if (!event) {
+      return res.status(404).json({ error: 'Event not found' });
+    }
+
+    const webhooks = await WebhookEndpoint.findAll({
+      where: { status: 'enabled', livemode: event.livemode },
+    });
+    const eventWebhooks = webhooks.filter((webhook) => webhook.enabled_events.includes(event.type));
+
+    if (eventWebhooks.length === 0) {
+      return res.json({ message: 'No enabled webhook endpoints found for this event type', scheduled: 0 });
+    }
+
+    let scheduled = 0;
+    // eslint-disable-next-line no-restricted-syntax
+    for (const webhook of eventWebhooks) {
+      // eslint-disable-next-line no-await-in-loop
+      const added = await addWebhookJob(event.id, webhook.id, { persist: false });
+      if (added) {
+        scheduled += 1;
+        logger.info('Manually scheduled webhook retry', { eventId: event.id, webhookId: webhook.id });
+      }
+    }
+
+    return res.json({
+      message: `Successfully scheduled ${scheduled} webhooks for retry`,
+      scheduled,
+      total: eventWebhooks.length,
+    });
+  } catch (err: any) {
+    logger.error('Failed to retry webhooks for event', err);
+    return res.status(500).json({ error: `Failed to retry webhooks: ${err.message}` });
+  }
+});
+
 export default router;

package/api/src/routes/meter-events.ts

@@ -1,6 +1,6 @@
 import { Router } from 'express';
 import Joi from 'joi';
-import { Op, QueryTypes } from 'sequelize';
+import { Op, QueryTypes, Sequelize } from 'sequelize';
 
 import { fromTokenToUnit } from '@ocap/util';
 import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
@@ -95,7 +95,10 @@ router.get('/', authMine, async (req, res) => {
     }
 
     if (query.customer_id) {
-      where['payload.customer_id'] = query.customer_id;
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        Sequelize.where(Sequelize.fn('json_extract', Sequelize.col('payload'), '$.customer_id'), query.customer_id)
+      );
     }
 
     if (query.start || query.end) {
@@ -171,7 +174,7 @@ router.get('/stats', authMine, async (req, res) => {
     };
 
     if (customerId) {
-      whereClause += " AND payload->>'customer_id' = :customerId";
+      whereClause += " AND json_extract(payload, '$.customer_id') = :customerId";
       replacements.customerId = customerId;
     }
 

package/api/src/store/migrations/20251208-database-performance-indexes.ts

@@ -0,0 +1,129 @@
+/* eslint-disable no-console */
+import { createIndexIfNotExists, type Migration } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  console.log('🚀 Starting database performance optimization...');
+
+  // meter_events
+  await createIndexIfNotExists(context, 'meter_events', ['status', 'created_at'], 'idx_meter_events_status_created');
+  await createIndexIfNotExists(
+    context,
+    'meter_events',
+    ['event_name', 'livemode', 'created_at'],
+    'idx_meter_events_event_livemode_created'
+  );
+
+  await context.sequelize.query(
+    "CREATE INDEX IF NOT EXISTS idx_meter_events_customer_status ON meter_events(json_extract(payload, '$.customer_id'), status, livemode, created_at)"
+  );
+  await context.sequelize.query(
+    "CREATE INDEX IF NOT EXISTS idx_meter_events_subscription_status ON meter_events(json_extract(payload, '$.subscription_id'), status, livemode, created_at)"
+  );
+
+  // credit_transactions
+  await createIndexIfNotExists(context, 'credit_transactions', ['created_at'], 'idx_credit_transactions_created');
+  await createIndexIfNotExists(
+    context,
+    'credit_transactions',
+    ['customer_id', 'created_at'],
+    'idx_credit_transactions_customer_created'
+  );
+  await createIndexIfNotExists(
+    context,
+    'credit_transactions',
+    ['meter_id', 'created_at'],
+    'idx_credit_transactions_meter_created'
+  );
+  await createIndexIfNotExists(
+    context,
+    'credit_transactions',
+    ['meter_event_name', 'created_at'],
+    'idx_credit_transactions_event_created'
+  );
+  await createIndexIfNotExists(
+    context,
+    'credit_transactions',
+    ['subscription_id', 'created_at'],
+    'idx_credit_transactions_subscription_created'
+  );
+
+  // credit_grants
+  await createIndexIfNotExists(
+    context,
+    'credit_grants',
+    ['customer_id', 'currency_id', 'status'],
+    'idx_credit_grants_customer_currency_status'
+  );
+  await createIndexIfNotExists(context, 'credit_grants', ['customer_id'], 'idx_credit_grants_customer');
+  await createIndexIfNotExists(context, 'credit_grants', ['currency_id'], 'idx_credit_grants_currency');
+  await createIndexIfNotExists(context, 'credit_grants', ['status'], 'idx_credit_grants_status');
+
+  // customers
+  await createIndexIfNotExists(context, 'customers', ['did'], 'idx_customers_did');
+
+  // subscriptions
+  await createIndexIfNotExists(context, 'subscriptions', ['customer_id'], 'idx_subscriptions_customer_id');
+
+  // meters
+  await createIndexIfNotExists(context, 'meters', ['livemode', 'status'], 'idx_meters_livemode_status');
+
+  // events
+  await createIndexIfNotExists(context, 'events', ['type', 'created_at'], 'idx_events_type_created');
+  await createIndexIfNotExists(
+    context,
+    'events',
+    ['object_type', 'object_id', 'created_at'],
+    'idx_events_object_type_id_created'
+  );
+  await createIndexIfNotExists(context, 'events', ['object_id', 'created_at'], 'idx_events_object_id_created');
+
+  // jobs
+  await createIndexIfNotExists(context, 'jobs', ['queue', 'will_run_at'], 'idx_jobs_queue_run_at');
+  await createIndexIfNotExists(context, 'jobs', ['cancelled', 'will_run_at'], 'idx_jobs_cancelled_run_at');
+
+  // invoices
+  await createIndexIfNotExists(context, 'invoices', ['status'], 'idx_invoices_status');
+
+  // checkout_sessions
+  await createIndexIfNotExists(
+    context,
+    'checkout_sessions',
+    ['payment_link_id', 'status', 'livemode'],
+    'idx_checkout_sessions_payment_link_status_livemode'
+  );
+
+  console.log('✅ Performance optimization completed');
+};
+
+export const down: Migration = async ({ context }) => {
+  console.log('🔄 Rolling back performance optimization...');
+
+  await context.removeIndex('meter_events', 'idx_meter_events_status_created');
+  await context.removeIndex('meter_events', 'idx_meter_events_event_livemode_created');
+  await context.removeIndex('meter_events', 'idx_meter_events_customer_status');
+  await context.removeIndex('meter_events', 'idx_meter_events_subscription_status');
+
+  await context.removeIndex('credit_transactions', 'idx_credit_transactions_created');
+  await context.removeIndex('credit_transactions', 'idx_credit_transactions_customer_created');
+  await context.removeIndex('credit_transactions', 'idx_credit_transactions_meter_created');
+  await context.removeIndex('credit_transactions', 'idx_credit_transactions_event_created');
+  await context.removeIndex('credit_transactions', 'idx_credit_transactions_subscription_created');
+
+  await context.removeIndex('credit_grants', 'idx_credit_grants_customer_currency_status');
+  await context.removeIndex('credit_grants', 'idx_credit_grants_customer');
+  await context.removeIndex('credit_grants', 'idx_credit_grants_currency');
+  await context.removeIndex('credit_grants', 'idx_credit_grants_status');
+
+  await context.removeIndex('customers', 'idx_customers_did');
+  await context.removeIndex('subscriptions', 'idx_subscriptions_customer_id');
+  await context.removeIndex('meters', 'idx_meters_livemode_status');
+  await context.removeIndex('events', 'idx_events_type_created');
+  await context.removeIndex('events', 'idx_events_object_type_id_created');
+  await context.removeIndex('events', 'idx_events_object_id_created');
+  await context.removeIndex('jobs', 'idx_jobs_queue_run_at');
+  await context.removeIndex('jobs', 'idx_jobs_cancelled_run_at');
+  await context.removeIndex('invoices', 'idx_invoices_status');
+  await context.removeIndex('checkout_sessions', 'idx_checkout_sessions_payment_link_status_livemode');
+
+  console.log('✅ Rollback completed');
+};

package/api/src/store/models/meter-event.ts

@@ -7,6 +7,7 @@ import {
   Model,
   Op,
   QueryTypes,
+  Sequelize,
   WhereOptions,
 } from 'sequelize';
 import type { LiteralUnion } from 'type-fest';
@@ -419,11 +420,18 @@ export class MeterEvent extends Model<InferAttributes<MeterEvent>, InferCreation
     if (status) {
       where.status = Array.isArray(status) ? { [Op.in]: status } : status;
     }
+
     if (subscriptionId) {
-      where['payload.subscription_id'] = subscriptionId;
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        Sequelize.where(Sequelize.fn('json_extract', Sequelize.col('payload'), '$.subscription_id'), subscriptionId)
+      );
     }
     if (customerId) {
-      where['payload.customer_id'] = customerId;
+      where[Op.and] = where[Op.and] || [];
+      where[Op.and].push(
+        Sequelize.where(Sequelize.fn('json_extract', Sequelize.col('payload'), '$.customer_id'), customerId)
+      );
     }
 
     return this._getPendingAmounts(where, currencyId);

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.22.29",
+  "version": "1.22.31",
   "scripts": {
     "dev": "blocklet dev --open",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
@@ -44,35 +44,35 @@
     ]
   },
   "dependencies": {
-    "@abtnode/cron": "^1.17.4-beta-20251204-152224-243ff54f",
-    "@arcblock/did": "^1.27.13",
+    "@abtnode/cron": "^1.17.4",
+    "@arcblock/did": "^1.27.14",
     "@arcblock/did-connect-react": "^3.2.11",
     "@arcblock/did-connect-storage-nedb": "^1.8.0",
-    "@arcblock/did-util": "^1.27.13",
-    "@arcblock/jwt": "^1.27.13",
+    "@arcblock/did-util": "^1.27.14",
+    "@arcblock/jwt": "^1.27.14",
     "@arcblock/react-hooks": "^3.2.11",
     "@arcblock/ux": "^3.2.11",
-    "@arcblock/validator": "^1.27.13",
-    "@blocklet/did-space-js": "^1.2.8",
+    "@arcblock/validator": "^1.27.14",
+    "@blocklet/did-space-js": "^1.2.9",
     "@blocklet/error": "^0.3.4",
-    "@blocklet/js-sdk": "^1.17.4-beta-20251204-152224-243ff54f",
-    "@blocklet/logger": "^1.17.4-beta-20251204-152224-243ff54f",
-    "@blocklet/payment-broker-client": "1.22.29",
-    "@blocklet/payment-react": "1.22.29",
-    "@blocklet/payment-vendor": "1.22.29",
-    "@blocklet/sdk": "^1.17.4-beta-20251204-152224-243ff54f",
+    "@blocklet/js-sdk": "^1.17.4",
+    "@blocklet/logger": "^1.17.4",
+    "@blocklet/payment-broker-client": "1.22.31",
+    "@blocklet/payment-react": "1.22.31",
+    "@blocklet/payment-vendor": "1.22.31",
+    "@blocklet/sdk": "^1.17.4",
     "@blocklet/ui-react": "^3.2.11",
-    "@blocklet/uploader": "^0.3.13",
-    "@blocklet/xss": "^0.3.11",
+    "@blocklet/uploader": "^0.3.14",
+    "@blocklet/xss": "^0.3.12",
     "@mui/icons-material": "^7.1.2",
     "@mui/lab": "7.0.0-beta.14",
     "@mui/material": "^7.1.2",
     "@mui/system": "^7.1.1",
-    "@ocap/asset": "^1.27.13",
-    "@ocap/client": "^1.27.13",
-    "@ocap/mcrypto": "^1.27.13",
-    "@ocap/util": "^1.27.13",
-    "@ocap/wallet": "^1.27.13",
+    "@ocap/asset": "^1.27.14",
+    "@ocap/client": "^1.27.14",
+    "@ocap/mcrypto": "^1.27.14",
+    "@ocap/util": "^1.27.14",
+    "@ocap/wallet": "^1.27.14",
     "@stripe/react-stripe-js": "^2.9.0",
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.5",
@@ -127,9 +127,9 @@
     "web3": "^4.16.0"
   },
   "devDependencies": {
-    "@abtnode/types": "^1.17.4-beta-20251204-152224-243ff54f",
+    "@abtnode/types": "^1.17.4",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.22.29",
+    "@blocklet/payment-types": "1.22.31",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -176,5 +176,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "8438b592c3709dc2ae5aeceb0cd883277de3d646"
+  "gitHead": "fc03087134d309474256b122eba125e4a01dd6c0"
 }

package/src/components/section/header.tsx

@@ -4,11 +4,12 @@ import type { ReactNode } from 'react';
 type Props = {
   title: string | ReactNode;
   children?: ReactNode;
+  action?: ReactNode;
   mb?: number;
   mt?: number;
 };
 
-export default function SectionHeader({ title, children = null, mb = 1.5, mt = 1.5 }: Props) {
+export default function SectionHeader({ title, children = null, action = null, mb = 1.5, mt = 1.5 }: Props) {
   return (
     <Stack
       className="section-header"
@@ -33,7 +34,7 @@ export default function SectionHeader({ title, children = null, mb = 1.5, mt = 1
         component="div">
         {title}
       </Typography>
-      {children}
+      {action || children}
     </Stack>
   );
 }

package/src/components/webhook/attempts.tsx

@@ -1,8 +1,9 @@
 /* eslint-disable react/no-unstable-nested-components */
 import CodeBlock from '@arcblock/ux/lib/CodeBlock';
-import { api, formatTime } from '@blocklet/payment-react';
+import Toast from '@arcblock/ux/lib/Toast';
+import { api, formatTime, ConfirmDialog } from '@blocklet/payment-react';
 import type { Paginated, TEvent, TWebhookAttemptExpanded } from '@blocklet/payment-types';
-import { CheckCircleOutlined, ErrorOutlined } from '@mui/icons-material';
+import { CheckCircleOutlined, ErrorOutlined, RefreshOutlined } from '@mui/icons-material';
 import {
   Box,
   Button,
@@ -17,7 +18,8 @@ import {
   Stack,
   Typography,
 } from '@mui/material';
-import { useInfiniteScroll } from 'ahooks';
+import { useLocaleContext } from '@arcblock/ux/lib/Locale/context';
+import { useInfiniteScroll, useRequest, useSetState } from 'ahooks';
 import React, { useEffect, useState } from 'react';
 
 import { isEmpty } from 'lodash';
@@ -51,7 +53,8 @@ type Props = {
 };
 
 export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '', event = undefined }: Props) {
-  const { data, loadMore, loadingMore, loading } = useInfiniteScroll<Paginated<TWebhookAttemptExpanded>>(
+  const { t } = useLocaleContext();
+  const { data, loadMore, loadingMore, loading, reload } = useInfiniteScroll<Paginated<TWebhookAttemptExpanded>>(
     (d) => {
       const size = 15;
       const page = d ? Math.ceil(d.list.length / size) + 1 : 1;
@@ -68,8 +71,27 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
   const [selected, setSelected] = useState<
     (TWebhookAttemptExpanded & { event: TEvent & { requestInfo?: RequestInfo } }) | null
   >(null);
+
+  const [state, setState] = useSetState({
+    retryEventId: '',
+  });
+
   const groupedAttempts = groupAttemptsByDate(attempts);
 
+  const { loading: retrying, run: retryWebhook } = useRequest(
+    (eventId: string) => api.post(`/api/events/${eventId}/retry-webhooks`).then((res) => res.data),
+    {
+      manual: true,
+      onSuccess: (result) => {
+        Toast.success(result.message || t('admin.event.retryOptions.success'));
+        reload();
+      },
+      onError: (err: any) => {
+        Toast.error(err.response?.data?.error || t('admin.event.retryOptions.error'));
+      },
+    }
+  );
+
   useEffect(() => {
     if (!selected && data?.list.length) {
       setSelected(data.list[0] as TWebhookAttemptExpanded);
@@ -80,6 +102,17 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
     setSelected(attempt);
   };
 
+  const handleRetryClick = (eventId: string) => {
+    setState({ retryEventId: eventId });
+  };
+
+  const handleConfirmRetry = () => {
+    if (state.retryEventId) {
+      retryWebhook(state.retryEventId);
+      setState({ retryEventId: '' });
+    }
+  };
+
   if (loading) {
     return <CircularProgress />;
   }
@@ -94,7 +127,7 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
             sx={{
               color: 'text.secondary',
             }}>
-            No Attempt
+            {t('admin.event.noAttempts')}
           </Typography>
         ) : (
           <>
@@ -140,7 +173,7 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
             </List>
             {hasMore && (
               <Button variant="text" type="button" color="inherit" onClick={loadMore} disabled={loadingMore}>
-                {loadingMore ? 'Loading more...' : 'Load more'}
+                {loadingMore ? t('common.loading') : t('common.loadMore')}
               </Button>
             )}
             {!hasMore && (
@@ -148,7 +181,7 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
                 sx={{
                   color: 'text.secondary',
                 }}>
-                No more data
+                {t('common.noMoreData')}
               </Typography>
             )}
           </>
@@ -161,9 +194,31 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
         }}>
         {selected && (
           <Stack direction="column" spacing={2} sx={{ pt: 3, pl: 3, borderLeft: '1px solid', borderColor: 'divider' }}>
-            <Typography variant="h6">{event_id ? selected.endpoint.url : selected.event.type}</Typography>
+            <Stack direction="row" sx={{ justifyContent: 'space-between', alignItems: 'center' }}>
+              <Typography variant="h6">{event_id ? selected.endpoint.url : selected.event.type}</Typography>
+              <Button
+                variant="outlined"
+                size="small"
+                startIcon={<RefreshOutlined />}
+                onClick={() => handleRetryClick(selected.event_id)}
+                disabled={retrying}>
+                {retrying ? t('admin.event.retrying') : t('admin.event.retry')}
+              </Button>
+            </Stack>
+            {state.retryEventId && (
+              <ConfirmDialog
+                onConfirm={handleConfirmRetry}
+                onCancel={() => setState({ retryEventId: '' })}
+                title={t('admin.event.retryOptions.title')}
+                message={t('admin.event.retryOptions.confirmMessage')}
+                loading={retrying}
+                color="primary"
+              />
+            )}
             <Box>
-              <Typography variant="h6">Response ({selected.response_status})</Typography>
+              <Typography variant="h6">
+                {t('admin.event.response')} ({selected.response_status})
+              </Typography>
               {/* @ts-ignore */}
               <CodeBlock language="json">{JSON.stringify(selected.response_body, null, 2)}</CodeBlock>
             </Box>
@@ -174,7 +229,7 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
                 sx={{
                   alignItems: 'center',
                 }}>
-                <Typography variant="h6">Request</Typography>
+                <Typography variant="h6">{t('admin.event.request')}</Typography>
                 <RequestInfoPopper
                   // @ts-ignore
                   requestInfo={selected?.event?.requestInfo}
@@ -194,7 +249,7 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
               sx={{
                 alignItems: 'center',
               }}>
-              <Typography variant="h6">Event Data</Typography>
+              <Typography variant="h6">{t('admin.event.eventData')}</Typography>
               <RequestInfoPopper
                 // @ts-ignore
                 requestInfo={event.requestInfo}

package/src/locales/en.tsx

@@ -31,6 +31,8 @@ export default flat({
     latinOnly:
       'Must contain at least one letter and cannot include Chinese characters or special characters such as <, >, ", \' or \\',
     loading: 'Loading...',
+    loadMore: 'Load more',
+    noMoreData: 'No more data',
     rechargeTime: 'Recharge Time',
     submit: 'Submit',
     custom: 'Custom',
@@ -1217,6 +1219,19 @@ export default flat({
       webhooks: 'Webhook Attempts',
       type: 'Type',
       pendingWebhooks: 'Pending Webhooks',
+      noAttempts: 'No Attempt',
+      retry: 'Retry',
+      retrying: 'Retrying...',
+      retryOptions: {
+        title: 'Retry Webhook',
+        confirmMessage:
+          'Are you sure you want to retry this webhook? This will send another request to the webhook endpoint.',
+        success: 'Webhook scheduled for retry',
+        error: 'Failed to retry webhook',
+      },
+      response: 'Response',
+      request: 'Request',
+      eventData: 'Event Data',
     },
     invoice: {
       view: 'View invoice',

package/src/locales/zh.tsx

@@ -29,6 +29,8 @@ export default flat({
     invalidCharacters: '无效字符',
     latinOnly: '至少包含一个字母，并且不能包含中文字符和特殊字符如 <, >、"、’ 或 \\',
     loading: '加载中...',
+    loadMore: '加载更多',
+    noMoreData: '没有更多数据',
     rechargeTime: '充值时间',
     submit: '提交',
     custom: '自定义',
@@ -1171,6 +1173,18 @@ export default flat({
       webhooks: '钩子调用',
       type: '类型',
       pendingWebhooks: '待处理的钩子',
+      noAttempts: '无调用记录',
+      retry: '重试',
+      retrying: '重试中...',
+      retryOptions: {
+        title: '重试 Webhook',
+        confirmMessage: '确定要重试此 webhook 吗？这将向 webhook 端点发送另一个请求。',
+        success: 'Webhook 已安排重试',
+        error: '重试 webhook 失败',
+      },
+      response: '响应',
+      request: '请求',
+      eventData: '事件数据',
       events: {
         dailyEventCount: '每日事件数量',
         dailyTotalValue: '每日总使用量',