payment-kit 1.22.29 → 1.22.30

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

@@ -110,13 +110,11 @@ 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,
+          skipExistCheck: true,
         });
-        logger.info('scheduled webhook job', { ...job, retryCount });
       });
     } else {
       await event.decrement('pending_webhooks');
@@ -183,3 +181,34 @@ 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;
+    skipExistCheck?: boolean;
+  } = {}
+) {
+  const { runAt, persist = false, skipExistCheck = false } = options;
+  const jobId = getWebhookJobId(eventId, webhookId);
+
+  if (!skipExistCheck) {
+    const exist = await webhookQueue.get(jobId);
+    if (exist) {
+      logger.info('Webhook job already exists, skipping', { eventId, webhookId, jobId });
+      return false;
+    }
+  }
+
+  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/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.30
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.22.29",
+  "version": "1.22.30",
   "scripts": {
     "dev": "blocklet dev --open",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
@@ -57,9 +57,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/payment-broker-client": "1.22.30",
+    "@blocklet/payment-react": "1.22.30",
+    "@blocklet/payment-vendor": "1.22.30",
     "@blocklet/sdk": "^1.17.4-beta-20251204-152224-243ff54f",
     "@blocklet/ui-react": "^3.2.11",
     "@blocklet/uploader": "^0.3.13",
@@ -129,7 +129,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.17.4-beta-20251204-152224-243ff54f",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.22.29",
+    "@blocklet/payment-types": "1.22.30",
     "@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": "78cac71748e6836069582ed293945b41b7c7af66"
 }

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 Toast from '@arcblock/ux/lib/Toast';
 import { api, formatTime } 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,7 @@ import {
   Stack,
   Typography,
 } from '@mui/material';
-import { useInfiniteScroll } from 'ahooks';
+import { useInfiniteScroll, useRequest } from 'ahooks';
 import React, { useEffect, useState } from 'react';
 
 import { isEmpty } from 'lodash';
@@ -51,7 +52,7 @@ type Props = {
 };
 
 export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '', event = undefined }: Props) {
-  const { data, loadMore, loadingMore, loading } = useInfiniteScroll<Paginated<TWebhookAttemptExpanded>>(
+  const { data, loadMore, loadingMore, loading, reload } = useInfiniteScroll<Paginated<TWebhookAttemptExpanded>>(
     (d) => {
       const size = 15;
       const page = d ? Math.ceil(d.list.length / size) + 1 : 1;
@@ -70,6 +71,20 @@ export default function WebhookAttempts({ event_id = '', webhook_endpoint_id = '
   >(null);
   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 || 'Webhook scheduled for retry');
+        reload();
+      },
+      onError: (err: any) => {
+        Toast.error(err.response?.data?.error || 'Failed to retry webhook');
+      },
+    }
+  );
+
   useEffect(() => {
     if (!selected && data?.list.length) {
       setSelected(data.list[0] as TWebhookAttemptExpanded);
@@ -161,7 +176,17 @@ 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={() => retryWebhook(selected.event_id)}
+                disabled={retrying}>
+                {retrying ? 'Retrying...' : 'Retry'}
+              </Button>
+            </Stack>
             <Box>
               <Typography variant="h6">Response ({selected.response_status})</Typography>
               {/* @ts-ignore */}