payment-kit 1.13.81 → 1.13.83

package/api/src/index.ts

@@ -55,9 +55,8 @@ handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));
 
 router.use('/api', routes);
-app.use(router);
 
-const isProduction = process.env.NODE_ENV === 'production' || process.env.ABT_NODE_SERVICE_ENV === 'production';
+const isProduction = process.env.BLOCKLET_MODE === 'production';
 
 const accessFormat =
   isProduction
@@ -76,6 +75,8 @@ if (isProduction) {
   });
 }
 
+app.use(router);
+
 if (isProduction) {
   const staticDir = path.resolve(process.env.BLOCKLET_APP_DIR!, 'dist');
   app.use(express.static(staticDir, { maxAge: '30d', index: false }));

package/api/src/libs/api.ts

@@ -0,0 +1,72 @@
+import { Op } from 'sequelize';
+import SqlWhereParser from 'sql-where-parser';
+
+const parser = new SqlWhereParser();
+
+export function handleOperator(operator: string, operands: any[]): any {
+  switch (operator) {
+    case 'AND':
+    case 'OR':
+      return handleCondition({ [operator]: operands });
+    case 'IN':
+      if (operands[0].NOT) {
+        return { [operands[0].NOT]: { [Op.notIn]: operands[1] } };
+      }
+      return { [operands[0]]: { [Op.in]: operands[1] } };
+    case 'LIKE':
+      if (operands[0].NOT) {
+        return { [operands[0].NOT]: { [Op.notLike]: operands[1] } };
+      }
+      return { [operands[0]]: { [Op.like]: operands[1] } };
+    case 'BETWEEN':
+      if (operands[0].NOT) {
+        return { [operands[0].NOT]: { [Op.notBetween]: [operands[1], operands[2]] } };
+      }
+      return { [operands[0]]: { [Op.between]: [operands[1], operands[2]] } };
+    case 'IS':
+      if (operands[1] && operands[1].NOT && Array.isArray(operands[1].NOT) && operands[1].NOT.length) {
+        return { [operands[0]]: { [Op.ne]: operands[1].NOT[0] } };
+      }
+      return { [operands[0]]: operands[1] };
+    case '=':
+      return { [operands[0]]: operands[1] };
+    case '!=':
+      return { [operands[0]]: { [Op.ne]: operands[1] } };
+    case '>':
+      return { [operands[0]]: { [Op.gt]: operands[1] } };
+    case '>=':
+      return { [operands[0]]: { [Op.gte]: operands[1] } };
+    case '<':
+      return { [operands[0]]: { [Op.lt]: operands[1] } };
+    case '<=':
+      return { [operands[0]]: { [Op.lte]: operands[1] } };
+    default:
+      console.error('Invalid operator', { operator, operands });
+      throw new Error('Operator not supported when parse query');
+  }
+}
+
+export function handleItem(item: Record<string, any>) {
+  const operator = Object.keys(item)[0] as string;
+  const operands = item[operator];
+  return handleOperator(operator, operands);
+}
+
+export function handleCondition(condition: any) {
+  if (condition.AND) {
+    return { [Op.and]: condition.AND.map(handleItem) };
+  }
+  if (condition.OR) {
+    return { [Op.or]: condition.OR.map(handleItem) };
+  }
+  return handleItem(condition);
+}
+
+export function getWhereFromQuery(query: string) {
+  if (!query) {
+    throw new Error('Can not parse empty query');
+  }
+
+  const parsed = parser.parse(query);
+  return handleCondition(parsed);
+}

package/api/src/routes/checkout-sessions.ts

@@ -1092,8 +1092,11 @@ router.get('/', auth, async (req, res) => {
     const prices = (await Price.findAll(condition)).map((x) => x.toJSON());
     const docs = list.map((x) => x.toJSON());
 
-    // @ts-ignore
-    docs.forEach((x) => expandLineItems(x.line_items, products, prices));
+    docs.forEach((x) => {
+      // @ts-ignore
+      expandLineItems(x.line_items, products, prices);
+      x.url = getUrl(`/checkout/${x.submit_type}/${x.id}`);
+    });
 
     res.json({ count, list: docs });
   } catch (err) {

package/api/src/routes/customers.ts

@@ -4,6 +4,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
+import { getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { formatMetadata } from '../libs/util';
 import { Customer } from '../store/models/customer';
@@ -53,6 +54,39 @@ router.get('/', auth, async (req, res) => {
   }
 });
 
+// search customers
+const searchSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  query: string;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  query: Joi.string(),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/search', auth, async (req, res) => {
+  const { page, pageSize, query, livemode } = await searchSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+
+  const where = getWhereFromQuery(query);
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  const { rows: list, count } = await Customer.findAndCountAll({
+    where,
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    include: [],
+  });
+
+  res.json({ count, list });
+});
+
 // eslint-disable-next-line consistent-return
 router.get('/me', user(), async (req, res) => {
   if (!req.user) {

package/api/src/routes/payment-intents.ts

@@ -4,6 +4,7 @@ import Joi from 'joi';
 import type { WhereOptions } from 'sequelize';
 
 import { syncStripPayment } from '../integrations/stripe/handlers/payment-intent';
+import { getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
@@ -25,7 +26,7 @@ const authPortal = authenticate<PaymentIntent>({
   },
 });
 
-// list payment links
+// list payment intents
 const paginationSchema = Joi.object<{
   page: number;
   pageSize: number;
@@ -102,6 +103,43 @@ router.get('/', authMine, async (req, res) => {
   }
 });
 
+// search payment intents
+const searchSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  query: string;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  query: Joi.string(),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/search', authMine, async (req, res) => {
+  const { page, pageSize, query, livemode } = await searchSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+
+  const where = getWhereFromQuery(query);
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  const { rows: list, count } = await Subscription.findAndCountAll({
+    where,
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    include: [
+      { model: PaymentCurrency, as: 'paymentCurrency' },
+      { model: PaymentMethod, as: 'paymentMethod' },
+      { model: Customer, as: 'customer' },
+    ],
+  });
+
+  res.json({ count, list });
+});
+
 router.get('/:id', authPortal, async (req, res) => {
   try {
     const doc = await PaymentIntent.findOne({

package/api/src/routes/prices.ts

@@ -4,6 +4,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
+import { getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { canUpsell } from '../libs/session';
 import { PaymentCurrency } from '../store/models/payment-currency';
@@ -40,6 +41,98 @@ export async function getExpandedPrice(id: string) {
   return null;
 }
 
+// list prices
+const paginationSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  livemode?: boolean;
+  active?: boolean;
+  type?: string;
+  currency_id?: string;
+  product_id?: string;
+  lookup_key?: string;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  livemode: Joi.boolean().empty(''),
+  active: Joi.boolean().empty(''),
+  type: Joi.string().empty(''),
+  currency_id: Joi.string().empty(''),
+  product_id: Joi.string().empty(''),
+  lookup_key: Joi.string().empty(''),
+});
+router.get('/', auth, async (req, res) => {
+  const { page, pageSize, active, livemode, ...query } = await paginationSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+  const where: WhereOptions<Price> = {};
+
+  if (typeof active === 'boolean') {
+    where.active = active;
+  }
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  ['type', 'currency_id', 'product_id', 'lookup_key'].forEach((key: string) => {
+    // @ts-ignore
+    if (query[key]) {
+      // @ts-ignore
+      where[key] = query[key].split(',').map((x: string) => x.trim()).filter(Boolean); // prettier-ignore
+    }
+  });
+
+  Object.keys(query)
+    .filter((x) => x.startsWith('recurring.'))
+    .forEach((key: string) => {
+      // @ts-ignore
+      where[key] = query[key];
+    });
+
+  const { rows, count } = await Price.findAndCountAll({
+    where,
+    attributes: ['id'],
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+  });
+
+  res.json({ count, list: await Promise.all(rows.map((x) => getExpandedPrice(x.id))) });
+});
+
+// search prices
+const searchSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  query: string;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  query: Joi.string(),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/search', auth, async (req, res) => {
+  const { page, pageSize, query, livemode } = await searchSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+
+  const where = getWhereFromQuery(query);
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  const { rows, count } = await Price.findAndCountAll({
+    where,
+    attributes: ['id'],
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+  });
+
+  res.json({ count, list: await Promise.all(rows.map((x) => getExpandedPrice(x.id))) });
+});
+
 // FIXME: @wangshijun use schema validation
 // create price
 // eslint-disable-next-line consistent-return
@@ -218,63 +311,4 @@ router.delete('/:id', auth, async (req, res) => {
   return res.json(price);
 });
 
-// list products and prices
-const paginationSchema = Joi.object<{
-  page: number;
-  pageSize: number;
-  livemode?: boolean;
-  active?: boolean;
-  type?: string;
-  currency_id?: string;
-  product_id?: string;
-  lookup_key?: string;
-}>({
-  page: Joi.number().integer().min(1).default(1),
-  pageSize: Joi.number().integer().min(1).max(100).default(20),
-  livemode: Joi.boolean().empty(''),
-  active: Joi.boolean().empty(''),
-  type: Joi.string().empty(''),
-  currency_id: Joi.string().empty(''),
-  product_id: Joi.string().empty(''),
-  lookup_key: Joi.string().empty(''),
-});
-router.get('/', auth, async (req, res) => {
-  const { page, pageSize, active, livemode, ...query } = await paginationSchema.validateAsync(req.query, {
-    stripUnknown: false,
-    allowUnknown: true,
-  });
-  const where: WhereOptions<Price> = {};
-
-  if (typeof active === 'boolean') {
-    where.active = active;
-  }
-  if (typeof livemode === 'boolean') {
-    where.livemode = livemode;
-  }
-  ['type', 'currency_id', 'product_id', 'lookup_key'].forEach((key: string) => {
-    // @ts-ignore
-    if (query[key]) {
-      // @ts-ignore
-      where[key] = query[key].split(',').map((x: string) => x.trim()).filter(Boolean); // prettier-ignore
-    }
-  });
-
-  Object.keys(query)
-    .filter((x) => x.startsWith('recurring.'))
-    .forEach((key: string) => {
-      // @ts-ignore
-      where[key] = query[key];
-    });
-
-  const { rows, count } = await Price.findAndCountAll({
-    where,
-    attributes: ['id'],
-    order: [['created_at', 'DESC']],
-    offset: (page - 1) * pageSize,
-    limit: pageSize,
-  });
-
-  res.json({ count, list: await Promise.all(rows.map((x) => getExpandedPrice(x.id))) });
-});
-
 export default router;

package/api/src/routes/products.ts

@@ -4,6 +4,7 @@ import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
+import { getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { formatMetadata } from '../libs/util';
 import { PaymentCurrency } from '../store/models/payment-currency';
@@ -140,6 +141,39 @@ router.get('/', auth, async (req, res) => {
   res.json({ count, list });
 });
 
+// search products
+const searchSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  query: string;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  query: Joi.string(),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/search', auth, async (req, res) => {
+  const { page, pageSize, query, livemode } = await searchSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+
+  const where = getWhereFromQuery(query);
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  const { rows: list, count } = await Product.findAndCountAll({
+    where,
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    include: [{ model: Price, as: 'prices' }],
+  });
+
+  res.json({ count, list });
+});
+
 // get product detail
 router.get('/:id', auth, async (req, res) => {
   res.json(await Product.expand(req.params.id as string));

package/api/src/routes/subscriptions.ts

@@ -7,6 +7,7 @@ import pick from 'lodash/pick';
 import uniq from 'lodash/uniq';
 import { Transaction, WhereOptions } from 'sequelize';
 
+import { getWhereFromQuery } from '../libs/api';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import { authenticate } from '../libs/security';
@@ -134,6 +135,44 @@ router.get('/', authMine, async (req, res) => {
   }
 });
 
+// search subscriptions
+const searchSchema = Joi.object<{
+  page: number;
+  pageSize: number;
+  query: string;
+  livemode?: boolean;
+}>({
+  page: Joi.number().integer().min(1).default(1),
+  pageSize: Joi.number().integer().min(1).max(100).default(20),
+  query: Joi.string(),
+  livemode: Joi.boolean().empty(''),
+});
+router.get('/search', auth, async (req, res) => {
+  const { page, pageSize, query, livemode } = await searchSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+
+  const where = getWhereFromQuery(query);
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+  const { rows: list, count } = await Subscription.findAndCountAll({
+    where,
+    order: [['created_at', 'DESC']],
+    offset: (page - 1) * pageSize,
+    limit: pageSize,
+    include: [
+      { model: PaymentCurrency, as: 'paymentCurrency' },
+      { model: PaymentMethod, as: 'paymentMethod' },
+      { model: SubscriptionItem, as: 'items' },
+      { model: Customer, as: 'customer' },
+    ],
+  });
+
+  res.json({ count, list });
+});
+
 // FIXME: exclude some sensitive fields from PaymentMethod
 router.get('/:id', authPortal, async (req, res) => {
   try {
@@ -392,22 +431,26 @@ router.put('/:id', auth, async (req, res) => {
 
     // handle updates
     const updates: Partial<TSubscription> = {};
+
+    // only metadata can be updated when immutable
     if (req.body.metadata) {
       updates.metadata = formatMetadata(req.body.metadata);
     }
     if (subscription.isImmutable()) {
-      if (updates.metadata) {
-        await subscription.update(updates);
-        return res.json({ subscription });
-      }
-      return res.status(400).json({ error: 'Only metadata can be updated when subscription is immutable' });
-    }
-    if (subscription.isActive() === false) {
-      return res.status(400).json({ error: 'Subscription can only be updated when active' });
+      await subscription.update(updates);
+      return res.json(subscription);
     }
+
+    // only metadata + description can be updated when not active
     if (req.body.description) {
       updates.description = req.body.description;
     }
+    if (subscription.isActive() === false) {
+      await subscription.update(updates);
+      return res.json(subscription);
+    }
+
+    // other updates are allowed
     if (req.body.payment_behavior) {
       updates.payment_behavior = req.body.payment_behavior;
     }
@@ -671,8 +714,7 @@ router.put('/:id', auth, async (req, res) => {
       }
 
       await subscription.update(updates);
-
-      return res.json({ subscription, invoice });
+      return res.json(subscription);
     });
   } catch (err) {
     console.error(err);

package/api/src/store/models/types.ts

@@ -5,8 +5,8 @@ export type Pagination<T = any> = T & {
   // offset based
   page?: number;
   pageSize?: number;
-  // TODO: cursor based
   limit?: number;
+  // TODO: cursor based
   starting_after?: string;
   ending_before?: string;
 
@@ -14,6 +14,10 @@ export type Pagination<T = any> = T & {
   [key: string]: any;
 };
 
+export type Searchable<T = any> = Pagination<T> & {
+  query: string;
+};
+
 export type Paginated<T = any> = {
   count: number;
   list: T[];

package/api/tests/libs/api.spec.ts

@@ -0,0 +1,157 @@
+import { Op } from 'sequelize';
+
+import { getWhereFromQuery } from '../../src/libs/api';
+
+describe('getWhereFromQuery', () => {
+  it('should correctly parse > operator', () => {
+    const result = getWhereFromQuery('response_status > 200');
+    expect(result).toEqual({ response_status: { [Op.gt]: 200 } });
+  });
+
+  it('should correctly parse < operator', () => {
+    const result = getWhereFromQuery('retry_count < 5');
+    expect(result).toEqual({ retry_count: { [Op.lt]: 5 } });
+  });
+
+  it('should correctly parse >= operator', () => {
+    const result = getWhereFromQuery('response_status >= 200');
+    expect(result).toEqual({ response_status: { [Op.gte]: 200 } });
+  });
+
+  it('should correctly parse <= operator', () => {
+    const result = getWhereFromQuery('retry_count <= 5');
+    expect(result).toEqual({ retry_count: { [Op.lte]: 5 } });
+  });
+
+  it('should correctly parse = operator', () => {
+    const result = getWhereFromQuery("status = 'succeeded'");
+    expect(result).toEqual({ status: 'succeeded' });
+  });
+
+  it('should correctly parse != operator', () => {
+    const result = getWhereFromQuery("status != 'failed'");
+    expect(result).toEqual({ status: { [Op.ne]: 'failed' } });
+  });
+
+  it('should correctly parse IS operator', () => {
+    const result = getWhereFromQuery("status IS 'failed'");
+    expect(result).toEqual({ status: 'failed' });
+  });
+
+  it('should correctly parse IS NOT operator', () => {
+    const result = getWhereFromQuery("status IS NOT 'failed'");
+    expect(result).toEqual({ status: { [Op.ne]: 'failed' } });
+  });
+
+  it('should correctly parse IS NOT operator: NULL', () => {
+    const result = getWhereFromQuery('status IS NOT null');
+    expect(result).toEqual({ status: { [Op.ne]: null } });
+  });
+
+  it('should correctly parse LIKE operator', () => {
+    const result = getWhereFromQuery("status LIKE 'fail'");
+    expect(result).toEqual({ status: { [Op.like]: 'fail' } });
+  });
+
+  it('should correctly parse NOT LIKE operator', () => {
+    const result = getWhereFromQuery("status NOT LIKE 'fail'");
+    expect(result).toEqual({ status: { [Op.notLike]: 'fail' } });
+  });
+
+  it('should correctly parse IN operator', () => {
+    const result = getWhereFromQuery('status in (1,2,3)');
+    expect(result).toEqual({ status: { [Op.in]: [1, 2, 3] } });
+  });
+
+  it('should correctly parse NOT IN operator', () => {
+    const result = getWhereFromQuery('status NOT IN (1,2,3)');
+    expect(result).toEqual({ status: { [Op.notIn]: [1, 2, 3] } });
+  });
+
+  it('should correctly parse BETWEEN operator', () => {
+    const result = getWhereFromQuery('age BETWEEN 1 AND 3');
+    expect(result).toEqual({ age: { [Op.between]: [1, 3] } });
+  });
+
+  it('should correctly parse NOT BETWEEN operator', () => {
+    const result = getWhereFromQuery('age NOT BETWEEN 1 AND 3');
+    expect(result).toEqual({ age: { [Op.notBetween]: [1, 3] } });
+  });
+
+  it('should correctly parse AND operator', () => {
+    const result = getWhereFromQuery('response_status >= 200 AND response_status < 300');
+    expect(result).toEqual({
+      [Op.and]: [{ response_status: { [Op.gte]: 200 } }, { response_status: { [Op.lt]: 300 } }],
+    });
+  });
+
+  it('should correctly parse AND operator with different field types', () => {
+    const result = getWhereFromQuery("status = 'succeeded' AND response_status = 200");
+    expect(result).toEqual({ [Op.and]: [{ status: 'succeeded' }, { response_status: 200 }] });
+  });
+
+  it('should correctly parse AND operator for BETWEEN condition', () => {
+    const result = getWhereFromQuery('retry_count >= 1 AND retry_count <= 3');
+    expect(result).toEqual({ [Op.and]: [{ retry_count: { [Op.gte]: 1 } }, { retry_count: { [Op.lte]: 3 } }] });
+  });
+
+  it('should correctly parse OR operator with different field types', () => {
+    const result = getWhereFromQuery("status = 'succeeded' OR response_status = 200");
+    expect(result).toEqual({ [Op.or]: [{ status: 'succeeded' }, { response_status: 200 }] });
+  });
+
+  it('should correctly parse OR operator with Boolean and Number fields', () => {
+    const result = getWhereFromQuery('livemode = true OR retry_count > 2');
+    expect(result).toEqual({ [Op.or]: [{ livemode: true }, { retry_count: { [Op.gt]: 2 } }] });
+  });
+
+  it('should correctly parse OR operator with boolean,number,string fields', () => {
+    const result = getWhereFromQuery('livemode = true OR retry_count > 2 OR status = "succeeded"');
+    expect(result).toEqual({
+      [Op.or]: [{ [Op.or]: [{ livemode: true }, { retry_count: { [Op.gt]: 2 } }] }, { status: 'succeeded' }],
+    });
+  });
+
+  it('should correctly parse OR operator with two String fields', () => {
+    const result = getWhereFromQuery("event_id LIKE '%event%' OR status != 'failed'");
+    expect(result).toEqual({ [Op.or]: [{ event_id: { [Op.like]: '%event%' } }, { status: { [Op.ne]: 'failed' } }] });
+  });
+
+  it('should throw an error when the query is empty', () => {
+    expect(() => getWhereFromQuery('')).toThrow(/empty query/);
+  });
+
+  it('should correctly parse AND operator x3 for metadata', () => {
+    const result = getWhereFromQuery(
+      // 'metadata.key IS NULL AND metadata.nftId="3" AND status IN ("succeeded","failed")'
+      'metadata.key IS NULL AND metadata.nftId="3" AND metadata.appId="4"'
+    );
+    expect(result).toEqual({
+      [Op.and]: [
+        {
+          [Op.and]: [{ 'metadata.key': null }, { 'metadata.nftId': '3' }],
+        },
+        { 'metadata.appId': '4' },
+      ],
+    });
+  });
+
+  it('should correctly parse AND + IN operator for metadata', () => {
+    const result = getWhereFromQuery(
+      'metadata.key IS NULL AND metadata.nftId="3" AND status IN ("succeeded","failed")'
+    );
+    expect(result).toEqual({
+      [Op.and]: [
+        {
+          [Op.and]: [{ 'metadata.key': null }, { 'metadata.nftId': '3' }],
+        },
+        { status: { [Op.in]: ['succeeded', 'failed'] } },
+      ],
+    });
+  });
+
+  // eslint-disable-next-line jest/no-disabled-tests
+  it.skip('should throw an error when an unsupported operator is used', () => {
+    expect(() => getWhereFromQuery('status === "failed"')).toThrow(/Operator not supported/);
+  });
+});

package/api/tests/libs/session.spec.ts

@@ -0,0 +1,135 @@
+import {
+  getCheckoutMode,
+  getPriceCurrencyOptions,
+  getPriceUintAmountByCurrency,
+  getRecurringPeriod,
+} from '../../src/libs/session';
+import type { TLineItemExpanded } from '../../src/store/models';
+
+describe('getCheckoutMode', () => {
+  it('should return "setup" when items array is empty', () => {
+    const result = getCheckoutMode([]);
+    expect(result).toBe('setup');
+  });
+
+  it('should return "setup" when all items are metered', () => {
+    const items = [
+      { price: { type: 'recurring', recurring: { usage_type: 'metered' } } },
+      { price: { type: 'recurring', recurring: { usage_type: 'metered' } } },
+    ];
+    const result = getCheckoutMode(items as TLineItemExpanded[]);
+    expect(result).toBe('setup');
+  });
+
+  it('should return "subscription" when some items are recurring', () => {
+    const items = [
+      { price: { type: 'recurring', recurring: { usage_type: 'metered' } } },
+      { price: { type: 'recurring' } },
+    ];
+    const result = getCheckoutMode(items as TLineItemExpanded[]);
+    expect(result).toBe('subscription');
+  });
+
+  it('should return "payment" when none of the above conditions are met', () => {
+    const items = [{ price: { type: 'one_time' } }, { price: { type: 'one_time' } }];
+    const result = getCheckoutMode(items as TLineItemExpanded[]);
+    expect(result).toBe('payment');
+  });
+});
+
+describe('getPriceCurrencyOptions', () => {
+  it('should return currency_options when it is an array', () => {
+    const price = {
+      currency_options: [
+        { currency_id: 'usd', unit_amount: 1000, tiers: null, custom_unit_amount: null },
+        { currency_id: 'eur', unit_amount: 900, tiers: null, custom_unit_amount: null },
+      ],
+      currency_id: 'usd',
+      unit_amount: 1000,
+    };
+    const result = getPriceCurrencyOptions(price as any);
+    expect(result).toEqual(price.currency_options);
+  });
+
+  it('should return an array with a single object when currency_options is not an array', () => {
+    const price = {
+      currency_id: 'usd',
+      unit_amount: 1000,
+    };
+    const result = getPriceCurrencyOptions(price as any);
+    expect(result).toEqual([{ currency_id: 'usd', unit_amount: 1000, tiers: null, custom_unit_amount: null }]);
+  });
+});
+describe('getPriceUintAmountByCurrency', () => {
+  it('should return the unit_amount of the matching currency_id in currency_options', () => {
+    const price = {
+      currency_options: [
+        { currency_id: 'usd', unit_amount: 1000 },
+        { currency_id: 'eur', unit_amount: 900 },
+      ],
+      currency_id: 'usd',
+      unit_amount: 1000,
+    };
+    const result = getPriceUintAmountByCurrency(price as any, 'eur');
+    expect(result).toBe(900);
+  });
+
+  it('should return the unit_amount of the price object when the currency_id is not found in currency_options', () => {
+    const price = {
+      currency_options: [
+        { currency_id: 'usd', unit_amount: 1000 },
+        { currency_id: 'eur', unit_amount: 900 },
+      ],
+      currency_id: 'usd',
+      unit_amount: 1000,
+    };
+    const result = getPriceUintAmountByCurrency(price as any, 'gbp');
+    expect(result).toBe(1000);
+  });
+
+  it('should return the unit_amount of the price object when currency_options is not an array', () => {
+    const price = {
+      currency_id: 'usd',
+      unit_amount: 1000,
+    };
+    const result = getPriceUintAmountByCurrency(price as any, 'eur');
+    expect(result).toBe(1000);
+  });
+});
+describe('getRecurringPeriod', () => {
+  it('should return the correct period in milliseconds when interval is "hour"', () => {
+    const recurring = { interval: 'hour', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(60 * 60 * 1000);
+  });
+
+  it('should return the correct period in milliseconds when interval is "day"', () => {
+    const recurring = { interval: 'day', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(24 * 60 * 60 * 1000);
+  });
+
+  it('should return the correct period in milliseconds when interval is "week"', () => {
+    const recurring = { interval: 'week', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(7 * 24 * 60 * 60 * 1000);
+  });
+
+  it('should return the correct period in milliseconds when interval is "month"', () => {
+    const recurring = { interval: 'month', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(30 * 24 * 60 * 60 * 1000);
+  });
+
+  it('should return the correct period in milliseconds when interval is "year"', () => {
+    const recurring = { interval: 'year', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(365 * 24 * 60 * 60 * 1000);
+  });
+
+  it('should return 0 when interval is an invalid value', () => {
+    const recurring = { interval: 'invalid', interval_count: '1' };
+    const result = getRecurringPeriod(recurring as any);
+    expect(result).toBe(0);
+  });
+});

package/{tests/api → api/tests}/libs/subscription.spec.ts

@@ -1,4 +1,4 @@
-import { getDaysUntilDue, getDueUnit } from '../../../api/src/libs/subscription';
+import { getDaysUntilDue, getDueUnit } from '../../src/libs/subscription';
 
 describe('getDueUnit', () => {
   it('should return 60 for recurring interval of "hour"', () => {

package/api/tests/libs/util.spec.ts

@@ -0,0 +1,177 @@
+import dayjs from '../../src/libs/dayjs';
+import {
+  createCodeGenerator,
+  createIdGenerator,
+  formatMetadata,
+  getMetadataFromQuery,
+  getNextRetry,
+  tryWithTimeout,
+} from '../../src/libs/util';
+
+describe('createIdGenerator', () => {
+  it('should return a function that generates an ID with the specified prefix and size', () => {
+    const generateId = createIdGenerator('test', 10);
+    const id = generateId();
+    expect(id.startsWith('test_')).toBe(true);
+    expect(id.length).toBe(15); // 10 for ID, 4 for prefix, 1 for underscore
+  });
+
+  it('should return a function that generates an ID with the specified prefix and default size when size is not provided', () => {
+    const generateId = createIdGenerator('test');
+    const id = generateId();
+    expect(id.startsWith('test_')).toBe(true);
+    expect(id.length).toBe(29); // 24 for ID, 4 for prefix, 1 for underscore
+  });
+
+  it('should return a function that generates an ID without a prefix when prefix is not provided', () => {
+    const generateId = createIdGenerator('', 10);
+    const id = generateId();
+    expect(id.startsWith('_')).toBe(false);
+    expect(id.length).toBe(10);
+  });
+});
+
+describe('createCodeGenerator', () => {
+  it('should return a function that generates a code with the specified prefix and size', () => {
+    const generateCode = createCodeGenerator('test', 10);
+    const code = generateCode();
+    expect(code.startsWith('test_')).toBe(true);
+    expect(code.length).toBe(15); // 10 for code, 4 for prefix, 1 for underscore
+  });
+
+  it('should return a function that generates a code with the specified prefix and default size when size is not provided', () => {
+    const generateCode = createCodeGenerator('test');
+    const code = generateCode();
+    expect(code.startsWith('test_')).toBe(true);
+    expect(code.length).toBe(29); // 24 for code, 4 for prefix, 1 for underscore
+  });
+
+  it('should return a function that generates a code without a prefix when prefix is not provided', () => {
+    const generateCode = createCodeGenerator('', 10);
+    const code = generateCode();
+    expect(code.startsWith('_')).toBe(false);
+    expect(code.length).toBe(10);
+  });
+});
+
+describe('formatMetadata', () => {
+  it('should return an empty object when metadata is undefined', () => {
+    const result = formatMetadata(undefined);
+    expect(result).toEqual({});
+  });
+
+  it('should return a formatted object when metadata is an array', () => {
+    const metadata = [
+      { key: 'key1', value: 'value1' },
+      { key: 'key2', value: '' },
+      { key: 'key3', value: 'value3' },
+    ];
+    const result = formatMetadata(metadata);
+    expect(result).toEqual({ key1: 'value1', key3: 'value3' });
+  });
+
+  it('should return a formatted object when metadata is an object', () => {
+    const metadata = {
+      key1: 'value1',
+      key2: '',
+      key3: 'value3',
+    };
+    const result = formatMetadata(metadata);
+    expect(result).toEqual({ key1: 'value1', key3: 'value3' });
+  });
+});
+
+describe('tryWithTimeout', () => {
+  it('should resolve with the result of the async function when it completes before the timeout', async () => {
+    const asyncFn = jest.fn().mockResolvedValue('result');
+    const result = await tryWithTimeout(asyncFn, 100);
+    expect(result).toBe('result');
+    expect(asyncFn).toHaveBeenCalled();
+  });
+
+  it('should reject with a timeout error when the async function does not complete before the timeout', async () => {
+    // eslint-disable-next-line no-promise-executor-return
+    const asyncFn = jest.fn().mockImplementation(() => new Promise((resolve) => setTimeout(resolve, 200)));
+    await expect(tryWithTimeout(asyncFn, 100)).rejects.toThrow('Operation timed out after 100 ms');
+    expect(asyncFn).toHaveBeenCalled();
+  });
+
+  it('should reject with the error of the async function when it rejects', async () => {
+    const asyncFn = jest.fn().mockRejectedValue(new Error('error'));
+    await expect(tryWithTimeout(asyncFn, 100)).rejects.toThrow('error');
+    expect(asyncFn).toHaveBeenCalled();
+  });
+
+  it('should throw an error when the provided asyncFn is not a function', () => {
+    // @ts-ignore
+    expect(() => tryWithTimeout(null)).toThrow('Must provide a valid asyncFn function');
+  });
+});
+
+describe('getNextRetry', () => {
+  it('should return the current time plus 1 second when retry count is 0', () => {
+    const now = dayjs().unix();
+    const result = getNextRetry(0);
+    expect(result).toBe(now + 1);
+  });
+
+  it('should return the current time plus 2 seconds when retry count is 1', () => {
+    const now = dayjs().unix();
+    const result = getNextRetry(1);
+    expect(result).toBe(now + 2);
+  });
+
+  it('should return the current time plus 4 seconds when retry count is 2', () => {
+    const now = dayjs().unix();
+    const result = getNextRetry(2);
+    expect(result).toBe(now + 4);
+  });
+
+  it('should return the current time plus 8 seconds when retry count is 3', () => {
+    const now = dayjs().unix();
+    const result = getNextRetry(3);
+    expect(result).toBe(now + 8);
+  });
+});
+
+describe('getMetadataFromQuery', () => {
+  it('should return an empty object when the query object is empty', () => {
+    const result = getMetadataFromQuery({});
+    expect(result).toEqual({});
+  });
+
+  it('should return an object with metadata when the query object contains metadata keys', () => {
+    const query = {
+      'metadata.key1': 'value1',
+      'metadata.key2': 'value2',
+    };
+    const result = getMetadataFromQuery(query);
+    expect(result).toEqual({
+      key1: 'value1',
+      key2: 'value2',
+    });
+  });
+
+  it('should return an object without non-metadata keys when the query object contains non-metadata keys', () => {
+    const query = {
+      'metadata.key1': 'value1',
+      key2: 'value2',
+    };
+    const result = getMetadataFromQuery(query);
+    expect(result).toEqual({
+      key1: 'value1',
+    });
+  });
+
+  it('should ignore metadata keys with undefined or null values', () => {
+    const query = {
+      'metadata.key1': 'value1',
+      'metadata.key2': undefined,
+      'metadata.key3': null,
+    };
+    const result = getMetadataFromQuery(query);
+    expect(result).toEqual({
+      key1: 'value1',
+    });
+  });
+});

package/api/third.d.ts

@@ -12,6 +12,8 @@ declare module 'flat';
 
 declare module '@abtnode/cron';
 
+declare module 'sql-where-parser';
+
 declare module 'cls-hooked';
 
 namespace Express {

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

package/jest.config.js

@@ -3,9 +3,11 @@ module.exports = {
   verbose: true,
   preset: 'ts-jest',
   testEnvironment: 'node',
-  collectCoverage: true,
   coverageDirectory: 'coverage',
+  restoreMocks: true,
   clearMocks: true,
+  globalSetup: '@blocklet/sdk/lib/util/jest-setup.js',
+  globalTeardown: '@blocklet/sdk/lib/util/jest-teardown.js',
   transform: {
     '^.+\\.ts?$': 'ts-jest',
   },

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "payment-kit",
-  "version": "1.13.81",
+  "version": "1.13.83",
   "scripts": {
     "dev": "COMPONENT_STORE_URL=https://test.store.blocklet.dev blocklet dev",
     "eject": "vite eject",
     "lint": "tsc --noEmit && eslint src api/src --ext .mjs,.js,.jsx,.ts,.tsx",
     "lint:fix": "npm run lint -- --fix",
     "format": "prettier -w src",
-    "test": "jest",
+    "test": "node scripts/jest.js",
     "coverage": "npm run test -- --coverage",
     "start": "cross-env NODE_ENV=development nodemon api/dev.ts -w api",
     "clean": "node scripts/build-clean.js",
@@ -42,15 +42,15 @@
     ]
   },
   "dependencies": {
-    "@abtnode/cron": "^1.16.20",
+    "@abtnode/cron": "1.16.21-beta-e828f413",
     "@arcblock/did": "^1.18.106",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
     "@arcblock/did-connect": "^2.8.23",
     "@arcblock/did-util": "^1.18.106",
     "@arcblock/jwt": "^1.18.106",
     "@arcblock/ux": "^2.8.23",
-    "@blocklet/logger": "^1.16.20",
-    "@blocklet/sdk": "^1.16.20",
+    "@blocklet/logger": "1.16.21-beta-e828f413",
+    "@blocklet/sdk": "1.16.21-beta-e828f413",
     "@blocklet/ui-react": "^2.8.23",
     "@blocklet/uploader": "^0.0.55",
     "@mui/icons-material": "^5.14.19",
@@ -97,6 +97,7 @@
     "react-router-dom": "^6.20.1",
     "rimraf": "^3.0.2",
     "sequelize": "^6.35.1",
+    "sql-where-parser": "^2.2.1",
     "sqlite3": "^5.1.6",
     "stripe": "^13.11.0",
     "typewriter-effect": "^2.21.0",
@@ -106,10 +107,10 @@
     "validator": "^13.11.0"
   },
   "devDependencies": {
-    "@abtnode/types": "^1.16.20",
+    "@abtnode/types": "1.16.21-beta-e828f413",
     "@arcblock/eslint-config": "^0.2.4",
     "@arcblock/eslint-config-ts": "^0.2.4",
-    "@did-pay/types": "1.13.81",
+    "@did-pay/types": "1.13.83",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
     "@types/dotenv-flow": "^3.3.3",
@@ -148,5 +149,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "ccdd4c815330b40a748619132db7bb3332850749"
+  "gitHead": "e6357508c38296224f7c493b6630a45fd359d6bc"
 }

package/scripts/jest.js

@@ -0,0 +1 @@
+require('../../../tools/jest');