payment-kit 1.29.1 → 1.29.2

package/api/src/routes/{pricing-table.ts → hono/pricing-table.ts}

@@ -1,27 +1,31 @@
+// Phase 3a (express→hono) — hono fork of routes/pricing-table.ts. Sub-app with
+// routes relative to /api/pricing-tables (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 { isValid } from '@arcblock/did';
 import { getUrl } from '@blocklet/sdk/lib/component';
-import { Router } from 'express';
+import { Hono } from 'hono';
 import Joi from 'joi';
 import merge from 'lodash/merge';
 import pick from 'lodash/pick';
 import uniq from 'lodash/uniq';
 import type { WhereOptions } from 'sequelize';
 
-import { checkPassportForPricingTable } from '../integrations/blocklet/passport';
-import { createListParamSchema, getOrder, MetadataSchema } from '../libs/api';
-import logger from '../libs/logger';
-import { authenticate } from '../libs/security';
-import { getBillingThreshold, getMinStakeAmount, isCreditMetered, isLineItemCurrencyAligned } from '../libs/session';
-import { getDaysUntilCancel, getDaysUntilDue } from '../libs/subscription';
-import { getDataObjectFromQuery } from '../libs/util';
-import { CheckoutSession } from '../store/models/checkout-session';
-import { PaymentCurrency } from '../store/models/payment-currency';
-import { Price } from '../store/models/price';
-import { PricingTable } from '../store/models/pricing-table';
-import { Product } from '../store/models/product';
+import { checkPassportForPricingTable } from '../../integrations/blocklet/passport';
+import { createListParamSchema, getOrder, MetadataSchema } from '../../libs/api';
+import logger from '../../libs/logger';
+import { authenticate } from '../../middlewares/hono/security';
+import { getBillingThreshold, getMinStakeAmount, isCreditMetered, isLineItemCurrencyAligned } from '../../libs/session';
+import { getDaysUntilCancel, getDaysUntilDue } from '../../libs/subscription';
+import { getDataObjectFromQuery } from '../../libs/util';
+import { CheckoutSession } from '../../store/models/checkout-session';
+import { PaymentCurrency } from '../../store/models/payment-currency';
+import { Price } from '../../store/models/price';
+import { PricingTable } from '../../store/models/pricing-table';
+import { Product } from '../../store/models/product';
 import { formatCheckoutSession } from './checkout-sessions';
 
-const router = Router();
+const app = new Hono();
 const auth = authenticate<PricingTable>({ component: true, roles: ['owner', 'admin'] });
 
 const PricingTableCreateSchema = Joi.object({
@@ -58,33 +62,34 @@ const PricingTableCreateSchema = Joi.object({
     .required(),
   branding_settings: Joi.object().allow(null, {}).optional(),
 }).unknown(true);
-// eslint-disable-next-line consistent-return
-router.post('/', auth, async (req, res) => {
-  const { error } = PricingTableCreateSchema.validate(req.body);
+
+app.post('/', auth, async (c) => {
+  const body = (c.get('sanitizedBody') ?? {}) as any;
+  const { error } = PricingTableCreateSchema.validate(body);
   if (error) {
-    return res.status(400).json({ error: `Pricing table create request invalid: ${error.message}` });
+    return c.json({ error: `Pricing table create request invalid: ${error.message}` }, 400);
   }
-  const raw: Partial<PricingTable> = PricingTable.format(req.body);
+  const raw: Partial<PricingTable> = PricingTable.format(body);
   raw.active = true;
   raw.locked = false;
-  raw.livemode = !!req.livemode;
-  raw.created_via = req.user?.via;
+  raw.livemode = !!c.get('livemode');
+  raw.created_via = c.get('user')?.via;
 
   if (!raw.items?.length) {
-    return res.status(400).json({ error: 'items should not be empty for pricing table' });
+    return c.json({ error: 'items should not be empty for pricing table' }, 400);
   }
 
   // @ts-ignore
   const items = await Price.expand(raw.items);
   for (let i = 0; i < items.length; i++) {
     if (isLineItemCurrencyAligned(items, i) === false) {
-      return res.status(400).json({ error: 'items should have same currency' });
+      return c.json({ error: 'items should have same currency' }, 400);
     }
   }
 
   const link = await PricingTable.create(raw as PricingTable);
 
-  res.json(link);
+  return c.json(link);
 });
 
 // list pricing tables
@@ -93,8 +98,9 @@ const paginationSchema = createListParamSchema<{
 }>({
   active: Joi.boolean().empty(''),
 });
-router.get('/', auth, async (req, res) => {
-  const { page, pageSize, ...query } = await paginationSchema.validateAsync(req.query, { stripUnknown: true });
+
+app.get('/', auth, async (c) => {
+  const { page, pageSize, ...query } = await paginationSchema.validateAsync(c.req.query(), { stripUnknown: true });
   const where: WhereOptions<PricingTable> = { 'metadata.preview': null };
 
   if (typeof query.active === 'boolean') {
@@ -107,7 +113,7 @@ router.get('/', auth, async (req, res) => {
   try {
     const { rows: list, count } = await PricingTable.findAndCountAll({
       where,
-      order: getOrder(req.query, [['created_at', 'DESC']]),
+      order: getOrder(c.req.query(), [['created_at', 'DESC']]),
       offset: (page - 1) * pageSize,
       limit: pageSize,
       include: [],
@@ -127,19 +133,18 @@ router.get('/', auth, async (req, res) => {
       });
     });
 
-    res.json({ count, list, paging: { page, pageSize } });
+    return c.json({ count, list, 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 } });
   }
 });
 
-// eslint-disable-next-line consistent-return
-router.get('/:id', async (req, res) => {
-  const doc = await PricingTable.findByPk(req.params.id);
+app.get('/:id', async (c) => {
+  const doc = await PricingTable.findByPk(c.req.param('id'));
 
   if (!doc) {
-    return res.status(404).json({ error: 'pricing table not found' });
+    return c.json({ error: 'pricing table not found' }, 404);
   }
 
   let currency = await PaymentCurrency.findOne({ where: { livemode: doc.livemode, is_base_currency: true } });
@@ -156,7 +161,7 @@ router.get('/:id', async (req, res) => {
       });
     }
   }
-  res.json({ ...expanded, currency });
+  return c.json({ ...expanded, currency });
 });
 
 // update
@@ -196,113 +201,115 @@ const PricingTableUpdateSchema = Joi.object({
   branding_settings: Joi.object().allow(null, {}).optional(),
 }).unknown(true);
 
-// eslint-disable-next-line consistent-return
-router.put('/:id', auth, async (req, res) => {
-  const { error } = PricingTableUpdateSchema.validate(req.body);
+app.put('/:id', auth, async (c) => {
+  const body = (c.get('sanitizedBody') ?? {}) as any;
+  const { error } = PricingTableUpdateSchema.validate(body);
   if (error) {
-    return res.status(400).json({ error: `Pricing table create request invalid: ${error.message}` });
+    return c.json({ error: `Pricing table create request invalid: ${error.message}` }, 400);
   }
-  const doc = await PricingTable.findByPk(req.params.id);
+  const doc = await PricingTable.findByPk(c.req.param('id'));
 
   if (!doc) {
-    return res.status(404).json({ error: 'pricing table not found' });
+    return c.json({ error: 'pricing table not found' }, 404);
   }
   if (doc.active === false) {
-    return res.status(403).json({ error: 'pricing table archived' });
+    return c.json({ error: 'pricing table archived' }, 403);
   }
   // if (doc.locked) {
-  //   return res.status(403).json({ error: 'pricing table locked' });
+  //   return c.json({ error: 'pricing table locked' }, 403);
   // }
 
-  await doc.update(PricingTable.format(Object.assign({}, doc.dataValues, req.body)));
+  await doc.update(PricingTable.format(Object.assign({}, doc.dataValues, body)));
 
-  res.json(doc);
+  return c.json(doc);
 });
 
 // archive
-router.put('/:id/archive', auth, async (req, res) => {
-  const doc = await PricingTable.findByPk(req.params.id);
+app.put('/:id/archive', auth, async (c) => {
+  const doc = await PricingTable.findByPk(c.req.param('id'));
 
   if (!doc) {
-    return res.status(404).json({ error: 'pricing table not found' });
+    return c.json({ error: 'pricing table not found' }, 404);
   }
 
   if (doc.active === false) {
-    return res.status(403).json({ error: 'pricing table already archived' });
+    return c.json({ error: 'pricing table already archived' }, 403);
   }
 
   await doc.update({ active: false });
-  return res.json(doc);
+  return c.json(doc);
 });
 
 // delete
-router.delete('/:id', auth, async (req, res) => {
-  const doc = await PricingTable.findByPk(req.params.id);
+app.delete('/:id', auth, async (c) => {
+  const doc = await PricingTable.findByPk(c.req.param('id'));
 
   if (!doc) {
-    return res.status(404).json({ error: 'pricing table not found' });
+    return c.json({ error: 'pricing table not found' }, 404);
   }
 
   if (doc.active === false) {
-    return res.status(403).json({ error: 'pricing table archived' });
+    return c.json({ error: 'pricing table archived' }, 403);
   }
 
   if (doc.locked) {
-    return res.status(403).json({ error: 'pricing table locked' });
+    return c.json({ error: 'pricing table locked' }, 403);
   }
 
   await doc.destroy();
-  return res.json(doc);
+  return c.json(doc);
 });
 
-router.post('/stash', auth, async (req, res) => {
+app.post('/stash', auth, async (c) => {
   try {
-    const raw: Partial<PricingTable> = req.body;
-    raw.id = `prctbl_${req.user?.did}`;
+    const body = (c.get('sanitizedBody') ?? {}) as any;
+    const raw: Partial<PricingTable> = body;
+    raw.id = `prctbl_${c.get('user')?.did}`;
     raw.active = true;
     raw.locked = false;
-    raw.livemode = !!req.livemode;
-    raw.created_via = req.user?.via;
+    raw.livemode = !!c.get('livemode');
+    raw.created_via = c.get('user')?.via;
     raw.metadata = { preview: '1' };
 
     let doc = await PricingTable.findByPk(raw.id);
     if (doc) {
-      await doc.update({ ...PricingTable.format(req.body), metadata: raw.metadata, livemode: raw.livemode });
+      await doc.update({ ...PricingTable.format(body), metadata: raw.metadata, livemode: raw.livemode });
     } else {
       doc = await PricingTable.create(raw as PricingTable);
     }
-    res.json(doc);
-  } catch (err) {
+    return c.json(doc);
+  } catch (err: any) {
     logger.error(err);
-    res.status(500).json({ error: err.message });
+    return c.json({ error: err.message }, 500);
   }
 });
 
 // start checkout session for pricing table
-// eslint-disable-next-line consistent-return
-router.post('/:id/checkout/:priceId', async (req, res) => {
-  const doc = await PricingTable.findByPk(req.params.id);
+app.post('/:id/checkout/:priceId', async (c) => {
+  const doc = await PricingTable.findByPk(c.req.param('id'));
 
   if (!doc) {
-    return res.status(404).json({ error: 'pricing table not found' });
+    return c.json({ error: 'pricing table not found' }, 404);
   }
   if (doc.active === false) {
-    return res.status(403).json({ error: 'pricing table archived' });
+    return c.json({ error: 'pricing table archived' }, 403);
   }
   if (doc.locked) {
-    return res.status(403).json({ error: 'pricing table locked' });
+    return c.json({ error: 'pricing table locked' }, 403);
   }
 
-  const lineItem = await doc.items.find((x) => x.price_id === req.params.priceId);
+  const lineItem = await doc.items.find((x) => x.price_id === c.req.param('priceId'));
   if (!lineItem) {
-    return res.status(403).json({ error: 'pricing table item not valid' });
+    return c.json({ error: 'pricing table item not valid' }, 403);
   }
 
   const price = await Price.findByPk(lineItem.price_id);
   if (!price) {
-    return res.status(403).json({ error: 'price not found' });
+    return c.json({ error: 'price not found' }, 403);
   }
 
+  const query = c.req.query();
+
   const raw: Partial<CheckoutSession> = await formatCheckoutSession({
     line_items: [{ price_id: lineItem.price_id, quantity: 1, adjustable_quantity: lineItem.adjustable_quantity }],
     ...pick(price, [
@@ -317,16 +324,16 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
       'cross_sell_behavior',
       'nft_mint_settings',
     ]),
-    subscription_data: merge(lineItem.subscription_data || {}, getDataObjectFromQuery(req.query, 'subscription_data'), {
+    subscription_data: merge(lineItem.subscription_data || {}, getDataObjectFromQuery(query, 'subscription_data'), {
       billing_threshold_amount: getBillingThreshold(lineItem.subscription_data),
       min_stake_amount: getMinStakeAmount(lineItem.subscription_data),
       no_stake: isCreditMetered(price),
     }),
     metadata: {
       ...doc.metadata,
-      ...getDataObjectFromQuery(req.query),
-      days_until_due: getDaysUntilDue(req.query),
-      days_until_cancel: getDaysUntilCancel(req.query),
+      ...getDataObjectFromQuery(query),
+      days_until_due: getDaysUntilDue(query),
+      days_until_cancel: getDaysUntilCancel(query),
       passport: await checkPassportForPricingTable(doc),
       pricing_table_id: doc.id,
     },
@@ -336,23 +343,23 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
 
   raw.livemode = doc.livemode;
   raw.created_via = 'portal';
-  raw.currency_id = (req.query?.currencyId as string) ?? currency?.id;
+  raw.currency_id = (query?.currencyId as string) ?? currency?.id;
 
-  if (req.query.redirect) {
-    raw.success_url = req.query.redirect as string;
-    raw.cancel_url = req.query.redirect as string;
+  if (query.redirect) {
+    raw.success_url = query.redirect as string;
+    raw.cancel_url = query.redirect as string;
     logger.info('use redirect from query when checkout from pricing table', { v: raw.success_url });
   }
-  if (req.query.cross_sell_behavior) {
-    raw.cross_sell_behavior = req.query.cross_sell_behavior as string;
+  if (query.cross_sell_behavior) {
+    raw.cross_sell_behavior = query.cross_sell_behavior as string;
     logger.info('use cross_sell_behavior from query when checkout from pricing table', { v: raw.cross_sell_behavior });
   }
   try {
-    if (req.query.nft_mint_factory && isValid(req.query.nft_mint_factory as string)) {
+    if (query.nft_mint_factory && isValid(query.nft_mint_factory as string)) {
       raw.nft_mint_settings = {
         enabled: true,
         behavior: 'per_checkout_session',
-        factory: req.query.nft_mint_factory as string,
+        factory: query.nft_mint_factory as string,
       };
       raw.nft_mint_status = 'pending';
       logger.info('use nft_mint_settings from query when checkout from pricing table', { v: raw.nft_mint_settings });
@@ -364,7 +371,7 @@ router.post('/:id/checkout/:priceId', async (req, res) => {
   }
 
   const session = await CheckoutSession.create(raw as any);
-  res.json({ ...session.toJSON(), url: getUrl(`/checkout/pay/${session.id}`) });
+  return c.json({ ...session.toJSON(), url: getUrl(`/checkout/pay/${session.id}`) });
 });
 
-export default router;
+export default app;