payment-kit 1.13.17 → 1.13.19

package/api/src/routes/prices.ts

@@ -23,15 +23,22 @@ router.post('/', auth, async (req, res) => {
   raw.created_via = req.user?.via as string;
 
   if (!raw.unit_amount) {
-    return res.status(400).json({ error: 'unit_amount is required' });
+    return res.status(400).json({ error: 'price unit_amount is required' });
   }
 
-  const currency = await PaymentCurrency.findByPk(raw.currency_id);
-  if (!currency) {
-    return res.status(400).json({ error: 'currency not found' });
+  if (raw.currency_options?.length === 0) {
+    raw.currency_options = [
+      { currency_id: raw.currency_id, unit_amount: raw.unit_amount, tiers: null, custom_unit_amount: null },
+    ];
   }
 
+  const currencies = await PaymentCurrency.findAll({ where: { active: true } });
+  const currency = currencies.find((x) => x.id === raw.currency_id);
+  if (!currency) {
+    return res.status(400).json({ error: `currency used in price or not active: ${raw.currency_id}` });
+  }
   raw.unit_amount = fromTokenToUnit(raw.unit_amount, currency.decimal).toString();
+  raw.currency_options = Price.formatCurrencies(raw.currency_options, currencies);
 
   const price = await Price.insert(raw);
 
@@ -47,7 +54,30 @@ router.get('/:id', auth, async (req, res) => {
     ],
   });
 
-  res.json(price);
+  if (price) {
+    const doc = price.toJSON();
+    if (doc.currency_options) {
+      const currencies = await PaymentCurrency.findAll();
+      doc.currency_options.forEach((x) => {
+        // @ts-ignore
+        x.currency = currencies.find((c) => c.id === x.currency_id);
+      });
+    } else {
+      doc.currency_options = [
+        {
+          currency_id: doc.currency_id,
+          unit_amount: doc.unit_amount,
+          // @ts-ignore
+          currency: doc.currency,
+          tiers: null,
+          custom_unit_amount: null,
+        },
+      ];
+    }
+    res.json(doc);
+  } else {
+    res.json(null);
+  }
 });
 
 // update price
@@ -62,28 +92,55 @@ router.put('/:id', auth, async (req, res) => {
     return res.status(403).json({ error: 'price archived' });
   }
 
-  const raw: Partial<Price> = Price.format(
+  const updates: Partial<Price> = Price.format(
     pick(
       req.body,
       price.locked
         ? ['nickname', 'description', 'metadata']
-        : ['type', 'model', 'active', 'livemode', 'nickname', 'recurring', 'description', 'tiers', 'unit_amount', 'transform_quantity', 'metadata', 'lookup_key'] // prettier-ignore
+        : ['type', 'model', 'active', 'livemode', 'nickname', 'recurring', 'description', 'tiers', 'unit_amount', 'transform_quantity', 'metadata', 'lookup_key', 'currency_options'] // prettier-ignore
     )
   );
 
-  if (raw.lookup_key) {
-    const exist = await Price.findOne({ where: { lookup_key: raw.lookup_key } });
+  if (updates.lookup_key) {
+    const exist = await Price.findOne({ where: { lookup_key: updates.lookup_key } });
     if (exist && exist.id !== price.id) {
-      return res.status(400).json({ error: `lookup_key ${raw.lookup_key} already used by ${exist.id}` });
+      return res.status(400).json({ error: `lookup_key ${updates.lookup_key} already used by ${exist.id}` });
     }
   }
 
-  if (raw.unit_amount) {
-    const currency = await PaymentCurrency.findByPk(price.currency_id);
-    raw.unit_amount = fromTokenToUnit(raw.unit_amount, (currency as PaymentCurrency).decimal).toString();
+  const currencies = await PaymentCurrency.findAll({ where: { active: true } });
+  if (updates.unit_amount) {
+    const currency = currencies.find((x) => x.id === price.currency_id);
+    if (!currency) {
+      return res.status(400).json({ error: `currency used in price not found or not active: ${price.currency_id}` });
+    }
+    updates.unit_amount = fromTokenToUnit(updates.unit_amount, currency.decimal).toString();
+  }
+  if (updates.currency_options) {
+    updates.currency_options = Price.formatCurrencies(updates.currency_options, currencies);
+    const base = updates.currency_options.find((x) => x.currency_id === price.currency_id);
+    if (!base) {
+      updates.currency_options.unshift({
+        currency_id: price.currency_id,
+        unit_amount: price.unit_amount,
+        tiers: null,
+        custom_unit_amount: null,
+      });
+    }
+    if (updates.unit_amount) {
+      const exist = updates.currency_options.find((x) => x.currency_id === price.currency_id);
+      if (exist) {
+        exist.unit_amount = updates.unit_amount;
+      }
+    }
+  } else if (updates.unit_amount) {
+    const exist = price.currency_options.find((x) => x.currency_id === price.currency_id);
+    if (exist) {
+      exist.unit_amount = updates.unit_amount;
+    }
   }
 
-  await price.update(Price.format(raw));
+  await price.update(Price.format(updates));
 
   return res.json(price);
 });

package/api/src/routes/products.ts

@@ -25,6 +25,7 @@ router.post('/', auth, async (req, res) => {
     'metadata',
     'statement_descriptor',
     'unit_label',
+    'nft_factory',
     'features',
     'metadata',
   ]);
@@ -41,16 +42,34 @@ router.post('/', auth, async (req, res) => {
       return res.status(400).json({ error: 'unit_amount is required for price' });
     }
 
-    const currency = await PaymentCurrency.findByPk(req.body.prices[0].currency_id);
-    if (!currency) {
-      return res.status(400).json({ error: 'currency_id not set for price' });
-    }
-
+    const currencies = await PaymentCurrency.findAll({ where: { active: true } });
     const pricesRaw = req.body.prices.map((price: Price & { model: 'string' }) => {
       price.product_id = product.id;
       price.active = product.active;
       price.livemode = product.livemode;
+      price.currency_id = price.currency_id || req.currency.id;
+
+      const currency = currencies.find((x) => x.id === price.currency_id);
+      if (!currency) {
+        throw new Error(`currency ${price.currency_id} used in price not found or inactive`);
+      }
+      if (!price.unit_amount) {
+        return res.status(400).json({ error: 'price.unit_amount is required' });
+      }
       price.unit_amount = fromTokenToUnit(price.unit_amount, currency.decimal).toString();
+
+      if (Array.isArray(price.currency_options)) {
+        price.currency_options = Price.formatCurrencies(price.currency_options, currencies);
+      } else {
+        price.currency_options = [];
+      }
+      price.currency_options.unshift({
+        currency_id: price.currency_id,
+        unit_amount: price.unit_amount,
+        tiers: null,
+        custom_unit_amount: null,
+      });
+
       return price;
     });
 
@@ -68,41 +87,51 @@ router.post('/', auth, async (req, res) => {
 // list products and prices
 const paginationSchema = Joi.object<{
   page: number;
-  size: number;
+  pageSize: number;
+  livemode?: boolean;
   active?: boolean;
   name?: string;
   description?: string;
-  livemode?: boolean;
 }>({
   page: Joi.number().integer().min(1).default(1),
-  size: Joi.number().integer().min(1).max(100).default(20),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  livemode: Joi.boolean().empty(''),
   active: Joi.boolean().empty(''),
   name: Joi.string().empty(''),
   description: Joi.string().empty(''),
-  livemode: Joi.boolean().empty(''),
 });
 router.get('/', auth, async (req, res) => {
-  const { page, size, ...query } = await paginationSchema.validateAsync(req.query, { stripUnknown: true });
+  const { page, pageSize, active, livemode, name, description, ...query } = await paginationSchema.validateAsync(
+    req.query,
+    { stripUnknown: false, allowUnknown: true }
+  );
   const where: WhereOptions<Product> = {};
 
-  if (typeof query.active === 'boolean') {
-    where.active = query.active;
+  if (typeof active === 'boolean') {
+    where.active = active;
   }
-  if (typeof query.livemode === 'boolean') {
-    where.livemode = query.livemode;
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
   }
-  if (query.name) {
-    where.name = { [Op.like]: `%${query.name}%` };
+  if (name) {
+    where.name = { [Op.like]: `%${name}%` };
   }
-  if (query.description) {
-    where.description = { [Op.like]: `%${query.description}%` };
+  if (description) {
+    where.description = { [Op.like]: `%${description}%` };
   }
 
+  Object.keys(query)
+    .filter((x) => x.startsWith('metadata.'))
+    .forEach((key: string) => {
+      // @ts-ignore
+      where[key] = query[key];
+    });
+
   const { rows: list, count } = await Product.findAndCountAll({
     where,
     order: [['created_at', 'DESC']],
-    offset: (page - 1) * size,
-    limit: size,
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
     include: [{ model: Price, as: 'prices' }],
   });
 
@@ -113,10 +142,37 @@ router.get('/', auth, async (req, res) => {
 router.get('/:id', auth, async (req, res) => {
   const product = await Product.findOne({
     where: { id: req.params.id },
-    include: [{ model: Price, as: 'prices', include: [{ model: PaymentCurrency, as: 'currency' }] }],
+    include: [
+      { model: Price, as: 'prices', include: [{ model: PaymentCurrency, as: 'currency' }] },
+      { model: Price, as: 'default_price' },
+    ],
   });
 
-  res.json(product);
+  if (product) {
+    const doc = product.toJSON();
+    const currencies = await PaymentCurrency.findAll();
+    // @ts-ignore
+    for (const price of doc.prices) {
+      if (Array.isArray(price.currency_options)) {
+        price.currency_options.forEach((x: any) => {
+          x.currency = currencies.find((c) => c.id === x.currency_id);
+        });
+        const base = price.currency_options.find((x: any) => x.currency_id === price.currency_id);
+        if (!base) {
+          price.currency_options.unshift(
+            pick(price, ['currency_id', 'unit_amount', 'tiers', 'custom_unit_amount', 'currency'])
+          );
+        }
+      } else {
+        price.currency_options = [
+          pick(price, ['currency_id', 'unit_amount', 'tiers', 'custom_unit_amount', 'currency']),
+        ];
+      }
+    }
+    res.json(doc);
+  } else {
+    res.json(null);
+  }
 });
 
 // update product
@@ -142,6 +198,7 @@ router.put('/:id', auth, async (req, res) => {
     'default_price_id',
     'unit_label',
     'features',
+    'nft_factory',
     'metadata',
   ]);
   if (updates.metadata) {

package/api/src/routes/settings.ts

@@ -8,27 +8,26 @@ import { PaymentMethod } from '../store/models/payment-method';
 const router = Router();
 
 router.get('/', async (req, res) => {
-  const where: WhereOptions<PaymentMethod> = {};
-
-  where.livemode = req.livemode;
+  const attributes = ['id', 'name', 'symbol', 'decimal', 'logo'];
+  const where: WhereOptions<PaymentMethod> = { livemode: req.livemode, active: true };
 
   const methods = await PaymentMethod.findAll({
     where,
-    order: [['created_at', 'DESC']],
-    include: [{ model: PaymentCurrency, as: 'payment_currencies' }],
+    order: [['created_at', 'ASC']],
+    include: [{ model: PaymentCurrency, as: 'payment_currencies', where: { active: true } }],
   });
 
   methods.forEach((method) => {
     // @ts-ignore
-    method.currencies = method.payment_currencies?.map((x) =>
-      pick(x, ['id', 'name', 'symbol', 'decimal', 'logo', 'is_base_currency'])
-    );
+    method.payment_currencies = method.payment_currencies?.map((x) => pick(x, attributes));
   });
 
   res.json({
-    paymentMethods: methods.map((x) => pick(x, ['id', 'name', 'type', 'logo', 'currencies'])),
-    // @ts-ignore
-    baseCurrency: methods[0].currencies.find((x) => x.is_base_currency),
+    paymentMethods: methods.map((x) => pick(x, ['id', 'name', 'type', 'logo', 'payment_currencies'])),
+    baseCurrency: await PaymentCurrency.findOne({
+      where: { is_base_currency: true, livemode: req.livemode },
+      attributes,
+    }),
   });
 });
 

package/api/src/routes/subscription-items.ts

@@ -40,17 +40,17 @@ router.post('/', auth, async (req, res) => {
 // @link https://stripe.com/docs/api/subscription_items/list
 const schema = Joi.object<{
   page: number;
-  size: number;
+  pageSize: number;
   subscription_id: string;
   livemode?: boolean;
 }>({
   page: Joi.number().integer().min(1).default(1),
-  size: Joi.number().integer().min(1).max(100).default(20),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
   subscription_id: Joi.string().required(),
   livemode: Joi.boolean().empty(''),
 });
 router.get('/', auth, async (req, res) => {
-  const { page, size, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+  const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
   const where: WhereOptions<SubscriptionItem> = { subscription_id: query.subscription_id };
 
   if (typeof query.livemode === 'boolean') {
@@ -61,8 +61,8 @@ router.get('/', auth, async (req, res) => {
     const { rows, count } = await SubscriptionItem.findAndCountAll({
       where,
       order: [['created_at', 'DESC']],
-      offset: (page - 1) * size,
-      limit: size,
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
       include: [],
     });
 

package/api/src/routes/subscriptions.ts

@@ -29,27 +29,40 @@ const authPortal = authenticate<Subscription>({
   },
 });
 
+const updateStripSubscription = async (doc: Subscription, updates: any) => {
+  if (doc.payment_details?.stripe?.subscription_id) {
+    const method = await PaymentMethod.findByPk(doc.default_payment_method_id);
+    if (method && method.type === 'stripe') {
+      const client = method.getStripe();
+      await client.subscriptions.update(doc.payment_details.stripe.subscription_id, updates);
+    }
+  }
+};
+
 const schema = Joi.object<{
   page: number;
-  size: number;
+  pageSize: number;
   status?: string;
   customer_id?: string;
   customer_did?: string;
   livemode?: boolean;
 }>({
   page: Joi.number().integer().min(1).default(1),
-  size: Joi.number().integer().min(1).max(100).default(20),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
   status: Joi.string().empty(''),
   customer_id: Joi.string().empty(''),
   customer_did: Joi.string().empty(''),
   livemode: Joi.boolean().empty(''),
 });
 router.get('/', authMine, async (req, res) => {
-  const { page, size, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+  const { page, pageSize, status, livemode, ...query } = await schema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
   const where: WhereOptions<Subscription> = {};
 
-  if (query.status) {
-    where.status = query.status
+  if (status) {
+    where.status = status
       .split(',')
       .map((x) => x.trim())
       .filter(Boolean);
@@ -63,16 +76,23 @@ router.get('/', authMine, async (req, res) => {
       where.customer_id = customer.id;
     }
   }
-  if (typeof query.livemode === 'boolean') {
-    where.livemode = query.livemode;
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
   }
 
+  Object.keys(query)
+    .filter((x) => x.startsWith('metadata.'))
+    .forEach((key: string) => {
+      // @ts-ignore
+      where[key] = query[key];
+    });
+
   try {
     const { rows: list, count } = await Subscription.findAndCountAll({
       where,
       order: [['created_at', 'DESC']],
-      offset: (page - 1) * size,
-      limit: size,
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
       include: [
         { model: PaymentCurrency, as: 'paymentCurrency' },
         { model: PaymentMethod, as: 'paymentMethod' },
@@ -147,6 +167,7 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     updates.cancel_at_period_end = true;
     updates.cancel_at = doc.current_period_end;
     updates.cancelation_details = { reason: 'cancellation_requested', feedback, comment };
+    updates.canceled_at = dayjs().unix();
   } else if (at === 'now') {
     updates.status = 'canceled';
     updates.cancel_at = dayjs().unix();
@@ -154,8 +175,10 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
   } else if (at === 'current_period_end') {
     updates.cancel_at_period_end = true;
     updates.cancel_at = doc.current_period_end;
+    updates.canceled_at = dayjs().unix();
   } else {
     updates.cancel_at = dayjs(time).unix();
+    updates.canceled_at = dayjs().unix();
     subscriptionQueue.push({
       id: `cancel-${doc.id}`,
       job: { subscriptionId: doc.id, action: 'cancel' },
@@ -163,6 +186,23 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
     });
   }
 
+  if (doc.payment_details?.stripe?.subscription_id) {
+    const method = await PaymentMethod.findByPk(doc.default_payment_method_id);
+    if (method && method.type === 'stripe') {
+      const client = method.getStripe();
+      if (updates.cancel_at_period_end) {
+        await client.subscriptions.update(doc.payment_details.stripe.subscription_id, {
+          cancel_at_period_end: updates.cancel_at_period_end,
+        });
+      } else {
+        await client.subscriptions.update(doc.payment_details.stripe.subscription_id, {
+          cancel_at: updates.cancel_at,
+          proration_behavior: 'none',
+        });
+      }
+    }
+  }
+
   await doc.update(updates);
 
   return res.json(doc);
@@ -181,7 +221,8 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not recoverable from cancellation' });
   }
 
-  await doc.update({ cancel_at: 0, cancel_at_period_end: false });
+  await updateStripSubscription(doc, { cancel_at_period_end: false });
+  await doc.update({ cancel_at_period_end: false });
 
   // reschedule jobs
   subscriptionQueue
@@ -213,6 +254,14 @@ router.put('/:id/pause', auth, async (req, res) => {
   }
 
   const timestamp = type === 'custom' ? dayjs(resumesAt).unix() : 0;
+
+  await updateStripSubscription(doc, {
+    pause_collection: {
+      resumes_at: timestamp || null,
+      behavior: behavior || 'keep_as_draft',
+    },
+  });
+
   await doc.update({
     status: 'paused',
     pause_collection: {
@@ -242,7 +291,9 @@ router.put('/:id/resume', auth, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not paused' });
   }
 
+  await updateStripSubscription(doc, { pause_collection: null });
   await doc.update({ status: 'active', pause_collection: undefined });
+
   subscriptionQueue
     .cancel(`resume-${doc.id}`)
     .then(() => logger.info('subscription resume job is canceled'))

package/api/src/routes/usage-records.ts

@@ -2,10 +2,11 @@
 import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';
+import { Op } from 'sequelize';
 
+import { forwardUsageRecordToStripe } from '../integrations/stripe/resource';
 import dayjs from '../libs/dayjs';
 import { authenticate } from '../libs/security';
-import { formatMetadata } from '../libs/util';
 import { Invoice, Price, Subscription, SubscriptionItem, UsageRecord } from '../store/models';
 
 const router = Router();
@@ -13,11 +14,7 @@ const auth = authenticate<UsageRecord>({ component: true, roles: ['owner', 'admi
 
 // @link https://stripe.com/docs/api/usage_records/create
 router.post('/', auth, async (req, res) => {
-  const raw: Partial<UsageRecord> = pick(req.body, ['timestamp', 'quantity', 'subscription_item_id', 'metadata']);
-  if (raw.metadata) {
-    raw.metadata = formatMetadata(raw.metadata);
-  }
-
+  const raw: Partial<UsageRecord> = pick(req.body, ['timestamp', 'quantity', 'subscription_item_id']);
   const item = await SubscriptionItem.findByPk(raw.subscription_item_id);
   if (!item) {
     return res.status(400).json({ error: `SubscriptionItem not found: ${raw.subscription_item_id}` });
@@ -28,10 +25,10 @@ router.post('/', auth, async (req, res) => {
     raw.timestamp = dayjs().unix();
   }
 
-  const exist = await UsageRecord.findOne({ where: { timestamp: raw.timestamp } });
-  if (exist) {
+  let doc = await UsageRecord.findOne({ where: { timestamp: raw.timestamp } });
+  if (doc) {
     if (req.body.action === 'increment') {
-      await exist.increment('quantity', { by: raw.quantity });
+      await doc.increment('quantity', { by: raw.quantity });
     } else {
       const subscription = await Subscription.findByPk(item.subscription_id);
       if (subscription?.billing_thresholds) {
@@ -39,29 +36,36 @@ router.post('/', auth, async (req, res) => {
           .status(400)
           .json({ error: 'UsageRecord action must be increment for subscriptions with billing_thresholds' });
       }
-      await exist.update({ quantity: raw.quantity });
+      await doc.update({ quantity: raw.quantity });
     }
+  } else {
+    raw.livemode = req.livemode;
+    doc = await UsageRecord.create(raw as UsageRecord);
   }
 
-  raw.livemode = req.livemode;
-  const doc = await UsageRecord.create(raw as UsageRecord);
+  await forwardUsageRecordToStripe(item, {
+    quantity: Number(raw.quantity),
+    timestamp: raw.timestamp,
+    action: req.body.action,
+  });
+
   return res.json(doc);
 });
 
 // @link https://stripe.com/docs/api/usage_records/subscription_item_summary_list
 const schema = Joi.object<{
   page: number;
-  size: number;
+  pageSize: number;
   subscription_item_id: string;
   livemode?: boolean;
 }>({
   page: Joi.number().integer().min(1).default(1),
-  size: Joi.number().integer().min(1).max(100).default(20),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
   subscription_item_id: Joi.string().required(),
   livemode: Joi.boolean().empty(''),
 });
-router.get('/', auth, async (req, res) => {
-  const { page, size, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+router.get('/summary', auth, async (req, res) => {
+  const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
 
   try {
     const item = await SubscriptionItem.findByPk(query.subscription_item_id, {
@@ -85,8 +89,8 @@ router.get('/', auth, async (req, res) => {
       where: { subscription_id: item.subscription_id },
       attributes: ['id', 'period_end', 'period_start'],
       order: [['created_at', 'DESC']],
-      offset: (page - 1) * size,
-      limit: size,
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
     });
 
     const list = await Promise.all(
@@ -117,4 +121,34 @@ router.get('/', auth, async (req, res) => {
   }
 });
 
+router.get('/', auth, async (req, res) => {
+  const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+
+  try {
+    const item = await SubscriptionItem.findByPk(query.subscription_item_id);
+    if (!item) {
+      return res.status(400).json({ error: `SubscriptionItem not found: ${query.subscription_item_id}` });
+    }
+    const subscription = await Subscription.findByPk(item.subscription_id);
+    if (!subscription) {
+      return res.status(400).json({ error: `Subscription not found: ${item.subscription_id}` });
+    }
+
+    const { rows: list, count } = await UsageRecord.findAndCountAll({
+      where: {
+        subscription_item_id: query.subscription_item_id,
+        timestamp: { [Op.gte]: subscription.current_period_start, [Op.lt]: subscription.current_period_end },
+      },
+      order: [['created_at', 'DESC']],
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+    });
+
+    res.json({ count, list });
+  } catch (err) {
+    console.error(err);
+    res.json({ count: 0, list: [] });
+  }
+});
+
 export default router;

package/api/src/routes/webhook-attempts.ts

@@ -10,19 +10,19 @@ const auth = authenticate<WebhookAttempt>({ component: true, roles: ['owner', 'a
 
 const schema = Joi.object<{
   page: number;
-  size: number;
+  pageSize: number;
   livemode?: boolean;
   event_id?: string;
   webhook_endpoint_id?: string;
 }>({
   page: Joi.number().integer().min(1).default(1),
-  size: Joi.number().integer().min(1).max(100).default(20),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
   livemode: Joi.boolean().empty(''),
   event_id: Joi.string().empty(''),
   webhook_endpoint_id: Joi.string().empty(''),
 });
 router.get('/', auth, async (req, res) => {
-  const { page, size, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
+  const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
   const where: WhereOptions<WebhookAttempt> = {};
 
   if (typeof query.livemode === 'boolean') {
@@ -39,8 +39,8 @@ router.get('/', auth, async (req, res) => {
     const { rows: list, count } = await WebhookAttempt.findAndCountAll({
       where,
       order: [['created_at', 'DESC']],
-      offset: (page - 1) * size,
-      limit: size,
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
       include: [
         { model: Event, as: 'event' },
         { model: WebhookEndpoint, as: 'endpoint' },