payment-kit 1.29.1 → 1.29.3

package/api/src/routes/{webhook-attempts.ts → hono/webhook-attempts.ts}

@@ -1,14 +1,18 @@
-import { Router } from 'express';
+// Phase 3 (express→hono) — hono fork of routes/webhook-attempts.ts. Sub-app with
+// routes relative to /api/webhook-attempts (mounted via mountResourceGroup). The
+// business logic is unchanged; only the express plumbing becomes hono:
+//   req.body → c.get('sanitizedBody'); res.status(n).json(x) → c.json(x, n).
+import { Hono } from 'hono';
 import Joi from 'joi';
 import type { WhereOptions } from 'sequelize';
 
-import { createListParamSchema, getOrder } from '../libs/api';
-import { authenticate } from '../libs/security';
-import { Event, WebhookAttempt, WebhookEndpoint } from '../store/models';
-import { blocklet } from '../libs/auth';
-import logger from '../libs/logger';
+import { createListParamSchema, getOrder } from '../../libs/api';
+import { authenticate } from '../../middlewares/hono/security';
+import { Event, WebhookAttempt, WebhookEndpoint } from '../../store/models';
+import { blocklet } from '../../libs/auth';
+import logger from '../../libs/logger';
 
-const router = Router();
+const app = new Hono();
 const auth = authenticate<WebhookAttempt>({ component: true, roles: ['owner', 'admin'] });
 
 const schema = createListParamSchema<{
@@ -18,8 +22,8 @@ const schema = createListParamSchema<{
   event_id: Joi.string().empty(''),
   webhook_endpoint_id: Joi.string().empty(''),
 });
-router.get('/', auth, async (req, res) => {
-  const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+app.get('/', auth, async (c) => {
+  const { page, pageSize, ...query } = await schema.validateAsync(c.req.query(), { stripUnknown: true });
   const where: WhereOptions<WebhookAttempt> = {};
 
   if (typeof query.livemode === 'boolean') {
@@ -35,7 +39,7 @@ router.get('/', auth, async (req, res) => {
   try {
     const { rows: list, count } = await WebhookAttempt.findAndCountAll({
       where,
-      order: getOrder(req.query, [['created_at', 'DESC']]),
+      order: getOrder(c.req.query(), [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       include: [
@@ -56,11 +60,11 @@ router.get('/', auth, async (req, res) => {
         return updated;
       })
     );
-    res.json({ count, list: updatedList, paging: { page, pageSize } });
+    return c.json({ count, list: updatedList, paging: { page, pageSize } });
   } catch (err) {
     logger.error(err);
-    res.json({ count: 0, list: [], paging: { page, pageSize } });
+    return c.json({ count: 0, list: [], paging: { page, pageSize } });
   }
 });
 
-export default router;
+export default app;

package/api/src/routes/hono/webhook-endpoints.ts

@@ -0,0 +1,126 @@
+// Phase 3 (express→hono) — hono fork of routes/webhook-endpoints.ts. Sub-app with
+// routes relative to /api/webhook-endpoints (mounted via mountResourceGroup). The
+// business logic is unchanged; only the express plumbing becomes hono:
+//   req.body → c.get('sanitizedBody'); res.status(n).json(x) → c.json(x, n).
+import { Hono } from 'hono';
+import Joi from 'joi';
+import pick from 'lodash/pick';
+import type { WhereOptions } from 'sequelize';
+
+import { createListParamSchema, getOrder, MetadataSchema } from '../../libs/api';
+import { formatMetadata } from '../../libs/util';
+import { WebhookEndpoint } from '../../store/models';
+import logger from '../../libs/logger';
+import { authenticate } from '../../middlewares/hono/security';
+
+const app = new Hono();
+const auth = authenticate<WebhookEndpoint>({ component: true, roles: ['owner', 'admin'] });
+
+app.post('/', auth, async (c) => {
+  const body = c.get('sanitizedBody') ?? {};
+  const raw: Partial<WebhookEndpoint> = pick(body, ['url', 'description', 'metadata', 'status', 'enabled_events']);
+  const exist = await WebhookEndpoint.findOne({ where: { url: raw.url } });
+  if (exist) {
+    return c.json({ error: 'webhook endpoint with same url already exist' }, 400);
+  }
+
+  raw.livemode = c.get('livemode');
+  raw.api_version = '2023-09-05';
+  raw.status = raw.status || 'enabled';
+  if (raw.metadata) {
+    const { error } = MetadataSchema.validate(raw.metadata);
+    if (error) {
+      return c.json({ error: `metadata invalid: ${error.message}` }, 400);
+    }
+    raw.metadata = formatMetadata(raw.metadata);
+  }
+
+  const doc = await WebhookEndpoint.create(raw as WebhookEndpoint);
+  return c.json(doc);
+});
+
+const schema = createListParamSchema<{
+  status?: string;
+}>({
+  status: Joi.string().empty(''),
+});
+app.get('/', auth, async (c) => {
+  const { page, pageSize, status, ...query } = await schema.validateAsync(c.req.query(), { stripUnknown: true });
+  const where: WhereOptions<WebhookEndpoint> = {};
+
+  if (status) {
+    where.status = status
+      .split(',')
+      .map((x: string) => x.trim())
+      .filter(Boolean);
+  }
+  Object.keys(query)
+    .filter((x) => x.startsWith('metadata.'))
+    .forEach((key: string) => {
+      // @ts-ignore
+      where[key] = query[key];
+    });
+
+  try {
+    const { rows: list, count } = await WebhookEndpoint.findAndCountAll({
+      where,
+      order: getOrder(c.req.query(), [['created_at', 'DESC']]),
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      include: [],
+    });
+
+    return c.json({ count, list, paging: { page, pageSize } });
+  } catch (err) {
+    logger.error(err);
+    return c.json({ count: 0, list: [], paging: { page, pageSize } });
+  }
+});
+
+app.get('/:id', auth, async (c) => {
+  try {
+    const doc = await WebhookEndpoint.findOne({
+      where: { id: c.req.param('id') },
+      include: [],
+    });
+    return c.json(doc);
+  } catch (err) {
+    logger.error(err);
+    return c.json(null);
+  }
+});
+
+app.put('/:id', auth, async (c) => {
+  const doc = await WebhookEndpoint.findByPk(c.req.param('id') as string);
+
+  if (!doc) {
+    return c.json({ error: 'webhook endpoint not found' }, 404);
+  }
+
+  const body = c.get('sanitizedBody') ?? {};
+  const updates: Partial<WebhookEndpoint> = pick(body, ['url', 'description', 'metadata', 'status', 'enabled_events']);
+  if (updates.metadata) {
+    const { error: metadataError } = MetadataSchema.validate(updates.metadata);
+    if (metadataError) {
+      return c.json({ error: `metadata invalid: ${metadataError.message}` }, 400);
+    }
+    updates.metadata = formatMetadata(updates.metadata);
+  }
+
+  await doc.update(updates);
+
+  return c.json(doc);
+});
+
+app.delete('/:id', auth, async (c) => {
+  const doc = await WebhookEndpoint.findByPk(c.req.param('id'));
+
+  if (!doc) {
+    return c.json({ error: 'webhook endpoint not found' }, 404);
+  }
+
+  await doc.destroy();
+  return c.json(doc);
+});
+
+export default app;