payment-kit 1.25.7 → 1.25.8

package/api/src/libs/credit-grant.ts

@@ -1,4 +1,5 @@
 import { BN } from '@ocap/util';
+import { Op } from 'sequelize';
 
 import { CreditGrant, Customer, PaymentCurrency, Subscription } from '../store/models';
 import { formatMetadata } from './util';
@@ -145,3 +146,135 @@ export function calculateExpiresAt(validDurationValue: number, validDurationUnit
 
   return expiresAt.unix();
 }
+
+/**
+ * Get credit grant statistics with flexible filtering
+ */
+export async function getCreditGrantStats(params: {
+  grantedBy?: string;
+  category?: 'paid' | 'promotional';
+  currencyId: string;
+  startDate: number;
+  endDate: number;
+  timezoneOffset?: number;
+}) {
+  const { grantedBy, category, currencyId, startDate, endDate, timezoneOffset } = params;
+  const offset = typeof timezoneOffset === 'number' ? timezoneOffset : 0;
+
+  // Fetch currency once at the start (since currencyId is required, results will only contain this currency)
+  const currency = await PaymentCurrency.findByPk(currencyId, {
+    attributes: ['id', 'name', 'symbol', 'decimal'],
+  });
+
+  if (!currency) {
+    return {
+      stats: {
+        currency_id: currencyId,
+        currency: null,
+        grant_count: 0,
+        total_granted: '0',
+        total_remaining: '0',
+        total_consumed: '0',
+      },
+      daily_stats: [],
+    };
+  }
+
+  const currencyJson = currency.toJSON();
+
+  // Build where clause
+  const where: any = {
+    currency_id: currencyId,
+    created_at: {
+      [Op.gte]: new Date(startDate * 1000),
+      [Op.lte]: new Date(endDate * 1000),
+    },
+  };
+
+  if (grantedBy) {
+    where['metadata.granted_by'] = grantedBy;
+  }
+
+  if (category) {
+    where.category = category;
+  }
+
+  const grants = (await CreditGrant.findAll({
+    where,
+    attributes: ['amount', 'remaining_amount', 'created_at'],
+    raw: true,
+  })) as any[];
+
+  const dailyMap = new Map<
+    string,
+    {
+      date: string;
+      grant_count: number;
+      total_granted: BN;
+      total_remaining: BN;
+    }
+  >();
+
+  const aggregate = {
+    grant_count: 0,
+    total_granted: new BN(0),
+    total_remaining: new BN(0),
+  };
+
+  grants.forEach((grant) => {
+    const date = dayjs.utc(grant.created_at).utcOffset(offset).format('YYYY-MM-DD');
+    const amount = grant.amount || '0';
+    const remainingAmount = grant.remaining_amount || '0';
+    if (!dailyMap.has(date)) {
+      dailyMap.set(date, {
+        date,
+        grant_count: 0,
+        total_granted: new BN(0),
+        total_remaining: new BN(0),
+      });
+    }
+
+    const daily = dailyMap.get(date)!;
+    daily.grant_count += 1;
+    daily.total_granted = daily.total_granted.add(new BN(amount));
+    daily.total_remaining = daily.total_remaining.add(new BN(remainingAmount));
+
+    aggregate.grant_count += 1;
+    aggregate.total_granted = aggregate.total_granted.add(new BN(amount));
+    aggregate.total_remaining = aggregate.total_remaining.add(new BN(remainingAmount));
+  });
+
+  const dailyStats = Array.from(dailyMap.values())
+    .sort((a, b) => a.date.localeCompare(b.date))
+    .map((day) => {
+      const totalGranted = day.total_granted.toString();
+      const totalRemaining = day.total_remaining.toString();
+      const totalConsumed = day.total_granted.sub(day.total_remaining).toString();
+
+      return {
+        date: day.date,
+        currency_id: currencyId,
+        grant_count: day.grant_count,
+        total_granted: totalGranted,
+        total_remaining: totalRemaining,
+        total_consumed: totalConsumed,
+      };
+    });
+
+  const totalGranted = aggregate.total_granted.toString();
+  const totalRemaining = aggregate.total_remaining.toString();
+  const totalConsumed = aggregate.total_granted.sub(aggregate.total_remaining).toString();
+  const statsWithConsumed = {
+    currency_id: currencyId,
+    currency: currencyJson,
+    grant_count: aggregate.grant_count,
+    total_granted: totalGranted,
+    total_remaining: totalRemaining,
+    total_consumed: totalConsumed,
+  };
+
+  return {
+    stats: statsWithConsumed,
+    daily_stats: dailyStats,
+  };
+}

package/api/src/routes/credit-grants.ts

@@ -20,7 +20,7 @@ import {
   Product,
   Subscription,
 } from '../store/models';
-import { createCreditGrant } from '../libs/credit-grant';
+import { createCreditGrant, getCreditGrantStats } from '../libs/credit-grant';
 import { expireGrant } from '../queues/credit-grant';
 import { getMeterPriceIdsFromSubscription } from '../libs/subscription';
 import { blocklet } from '../libs/auth';
@@ -48,7 +48,7 @@ const authPortal = authenticate<CreditGrant>({
 const creditGrantSchema = Joi.object({
   amount: Joi.number().required(),
   currency_id: Joi.string().max(15).optional(),
-  customer_id: Joi.string().max(18).required(),
+  customer_id: Joi.string().max(45).required(),
   name: Joi.string().max(255).optional(),
   category: Joi.string().valid('paid', 'promotional').required(),
   priority: Joi.number().integer().min(0).max(100).default(50),
@@ -661,6 +661,59 @@ router.get('/verify-availability', authMine, async (req, res) => {
   }
 });
 
+// Schema for stats endpoint
+const statsSchema = Joi.object({
+  // Credit granted by did
+  // The did that grants the credit is not necessarily the component that send the request.
+  granted_by: Joi.string().optional(),
+  category: Joi.string().valid('paid', 'promotional').optional(),
+  currency_id: Joi.string().required(),
+  start_date: Joi.number().integer().required(),
+  end_date: Joi.number().integer().required(),
+  timezone_offset: Joi.number()
+    .integer()
+    .min(-12 * 60)
+    .max(14 * 60)
+    .optional(),
+});
+
+// Get credit grant statistics with flexible filtering
+router.get('/stats', auth, async (req, res) => {
+  try {
+    const { error, value } = statsSchema.validate(req.query, { stripUnknown: true });
+    if (error) {
+      return res.status(400).json({ error: error.message });
+    }
+
+    const {
+      granted_by: grantedBy,
+      category,
+      currency_id: currencyId,
+      start_date: startDate,
+      end_date: endDate,
+      timezone_offset: timezoneOffset,
+    } = value;
+
+    if (startDate > endDate) {
+      return res.status(400).json({ error: 'start_date must be less than or equal to end_date' });
+    }
+
+    const result = await getCreditGrantStats({
+      grantedBy,
+      category,
+      currencyId,
+      startDate,
+      endDate,
+      timezoneOffset,
+    });
+
+    return res.json(result);
+  } catch (err: any) {
+    logger.error('Error getting credit grant stats', { error: err.message, query: req.query });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 router.get('/:id', authPortal, async (req, res) => {
   const creditGrant = (await CreditGrant.findByPk(req.params.id, {
     include: [
@@ -745,7 +798,7 @@ router.post('/', auth, async (req, res) => {
     const creditGrant = await createCreditGrant({
       amount: unitAmount,
       currency_id: currencyId,
-      customer_id: req.body.customer_id,
+      customer_id: customer.id,
       name: req.body.name,
       category: req.body.category,
       priority: req.body.priority,
@@ -764,7 +817,7 @@ router.post('/', auth, async (req, res) => {
       paymentCurrency,
     });
   } catch (err: any) {
-    logger.error('create credit grant failed', { error: err.message, request: req.body });
+    logger.error('create credit grant failed', { error: err, request: req.body });
     return res.status(400).json({ error: err.message });
   }
 });

package/api/src/store/migrations/20260129-add-grantor-did-index.ts

@@ -0,0 +1,52 @@
+import type { QueryInterface } from 'sequelize';
+import type { Migration } from '../migrate';
+
+const indexExists = async (table: string, indexName: string, queryInterface: QueryInterface) => {
+  const indexes = await queryInterface.showIndex(table);
+  return indexes && Array.isArray(indexes) && indexes.some((index: { name: string }) => index.name === indexName);
+};
+
+const createIndexIfNotExists = async (
+  queryInterface: QueryInterface,
+  table: string,
+  indexName: string,
+  rawSQL: string
+) => {
+  if (await indexExists(table, indexName, queryInterface)) {
+    /* eslint-disable no-console */
+    console.log(`Index ${indexName} already exists on ${table}, skipping...`);
+    return;
+  }
+  await queryInterface.sequelize.query(rawSQL);
+};
+
+export const up: Migration = async ({ context: queryInterface }) => {
+  try {
+    await createIndexIfNotExists(
+      queryInterface,
+      'credit_grants',
+      'idx_credit_grant_stats_by_grantor',
+      "CREATE INDEX idx_credit_grant_stats_by_grantor ON credit_grants(json_extract(metadata, '$.granted_by'), currency_id, created_at) WHERE json_extract(metadata, '$.granted_by') IS NOT NULL"
+    );
+
+    console.log(
+      'Successfully created partial index on metadata.granted_by, currency_id, created_at (WHERE granted_by IS NOT NULL)'
+    );
+  } catch (error) {
+    console.error('Failed to create granted_by index', error);
+    throw error;
+  }
+};
+
+export const down: Migration = async ({ context: queryInterface }) => {
+  try {
+    const indexName = 'idx_credit_grant_stats_by_grantor';
+    if (await indexExists('credit_grants', indexName, queryInterface)) {
+      await queryInterface.removeIndex('credit_grants', indexName);
+      console.log(`Successfully removed index ${indexName}`);
+    }
+  } catch (error) {
+    console.error('Failed to remove granted_by index', error);
+    throw error;
+  }
+};

package/api/tests/libs/credit-grant.spec.ts

@@ -0,0 +1,184 @@
+import { Op } from 'sequelize';
+
+import { getCreditGrantStats } from '../../src/libs/credit-grant';
+import { CreditGrant, PaymentCurrency } from '../../src/store/models';
+
+jest.mock('../../src/libs/logger', () => ({
+  __esModule: true,
+  default: {
+    info: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    debug: jest.fn(),
+  },
+}));
+
+jest.mock('../../src/libs/subscription', () => ({
+  getMeterPriceIdsFromSubscription: jest.fn(),
+}));
+
+jest.mock('../../src/store/models', () => ({
+  CreditGrant: {
+    findAll: jest.fn(),
+  },
+  PaymentCurrency: {
+    findByPk: jest.fn(),
+  },
+  Customer: {
+    findByPk: jest.fn(),
+  },
+  Subscription: {
+    findByPk: jest.fn(),
+  },
+}));
+
+describe('libs/credit-grant.ts', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  it('aggregates daily stats and totals', async () => {
+    const currencyJson = { id: 'cur_1', name: 'USD', symbol: '$', decimal: 2 };
+    (PaymentCurrency.findByPk as jest.Mock).mockResolvedValue({
+      ...currencyJson,
+      toJSON: () => currencyJson,
+    });
+
+    (CreditGrant.findAll as jest.Mock).mockResolvedValue([
+      {
+        amount: '100',
+        remaining_amount: '40',
+        created_at: new Date('2024-01-01T01:00:00Z'),
+      },
+      {
+        amount: '200',
+        remaining_amount: '200',
+        created_at: new Date('2024-01-01T10:00:00Z'),
+      },
+      {
+        amount: '50',
+        remaining_amount: '10',
+        created_at: new Date('2024-01-02T05:00:00Z'),
+      },
+    ]);
+
+    const result = await getCreditGrantStats({
+      currencyId: 'cur_1',
+      startDate: 1704067200,
+      endDate: 1704240000,
+    });
+
+    expect(PaymentCurrency.findByPk).toHaveBeenCalledWith('cur_1', {
+      attributes: ['id', 'name', 'symbol', 'decimal'],
+    });
+
+    const callArg = (CreditGrant.findAll as jest.Mock).mock.calls[0][0];
+    expect(callArg.attributes).toEqual(['amount', 'remaining_amount', 'created_at']);
+    expect(callArg.raw).toBe(true);
+
+    expect(result.stats).toEqual({
+      currency_id: 'cur_1',
+      currency: currencyJson,
+      grant_count: 3,
+      total_granted: '350',
+      total_remaining: '250',
+      total_consumed: '100',
+    });
+
+    expect(result.daily_stats).toEqual([
+      {
+        date: '2024-01-01',
+        currency_id: 'cur_1',
+        grant_count: 2,
+        total_granted: '300',
+        total_remaining: '240',
+        total_consumed: '60',
+      },
+      {
+        date: '2024-01-02',
+        currency_id: 'cur_1',
+        grant_count: 1,
+        total_granted: '50',
+        total_remaining: '10',
+        total_consumed: '40',
+      },
+    ]);
+  });
+
+  it('groups grants by day using timezone offset', async () => {
+    const currencyJson = { id: 'cur_2', name: 'USD', symbol: '$', decimal: 2 };
+    (PaymentCurrency.findByPk as jest.Mock).mockResolvedValue({
+      ...currencyJson,
+      toJSON: () => currencyJson,
+    });
+
+    (CreditGrant.findAll as jest.Mock).mockResolvedValue([
+      {
+        amount: '10',
+        remaining_amount: '5',
+        created_at: new Date('2024-01-01T23:30:00Z'),
+      },
+      {
+        amount: '20',
+        remaining_amount: '0',
+        created_at: new Date('2024-01-02T01:00:00Z'),
+      },
+    ]);
+
+    const result = await getCreditGrantStats({
+      currencyId: 'cur_2',
+      startDate: 1704067200,
+      endDate: 1704240000,
+      timezoneOffset: 480,
+    });
+
+    expect(result.daily_stats).toEqual([
+      {
+        date: '2024-01-02',
+        currency_id: 'cur_2',
+        grant_count: 2,
+        total_granted: '30',
+        total_remaining: '5',
+        total_consumed: '25',
+      },
+    ]);
+  });
+
+  it('builds where clause with grantedBy and category filters', async () => {
+    const currencyJson = { id: 'cur_3', name: 'USD', symbol: '$', decimal: 2 };
+    (PaymentCurrency.findByPk as jest.Mock).mockResolvedValue({
+      ...currencyJson,
+      toJSON: () => currencyJson,
+    });
+    (CreditGrant.findAll as jest.Mock).mockResolvedValue([]);
+
+    const startDate = 1704067200;
+    const endDate = 1704153600;
+
+    const result = await getCreditGrantStats({
+      currencyId: 'cur_3',
+      startDate,
+      endDate,
+      grantedBy: 'did:example:123',
+      category: 'paid',
+    });
+
+    const callArg = (CreditGrant.findAll as jest.Mock).mock.calls[0][0];
+    expect(callArg.where.currency_id).toBe('cur_3');
+    expect(callArg.where['metadata.granted_by']).toBe('did:example:123');
+    expect(callArg.where.category).toBe('paid');
+    expect(callArg.where.created_at[Op.gte]).toEqual(new Date(startDate * 1000));
+    expect(callArg.where.created_at[Op.lte]).toEqual(new Date(endDate * 1000));
+
+    expect(result.stats).toEqual({
+      currency_id: 'cur_3',
+      currency: currencyJson,
+      grant_count: 0,
+      total_granted: '0',
+      total_remaining: '0',
+      total_consumed: '0',
+    });
+    expect(result.daily_stats).toEqual([]);
+  });
+});

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.25.7",
+  "version": "1.25.8",
   "scripts": {
     "dev": "blocklet dev --open",
     "prelint": "npm run types",
@@ -59,9 +59,9 @@
     "@blocklet/error": "^0.3.5",
     "@blocklet/js-sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/logger": "^1.17.8-beta-20260104-120132-cb5b1914",
-    "@blocklet/payment-broker-client": "1.25.7",
-    "@blocklet/payment-react": "1.25.7",
-    "@blocklet/payment-vendor": "1.25.7",
+    "@blocklet/payment-broker-client": "1.25.8",
+    "@blocklet/payment-react": "1.25.8",
+    "@blocklet/payment-vendor": "1.25.8",
     "@blocklet/sdk": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@blocklet/ui-react": "^3.4.7",
     "@blocklet/uploader": "^0.3.19",
@@ -132,7 +132,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.17.8-beta-20260104-120132-cb5b1914",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.25.7",
+    "@blocklet/payment-types": "1.25.8",
     "@types/cookie-parser": "^1.4.9",
     "@types/cors": "^2.8.19",
     "@types/debug": "^4.1.12",
@@ -179,5 +179,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "0aa950a5d3f01a150ec21c66e2efeaf81ee1cc69"
+  "gitHead": "b40c46bcf52d4c1758bb10eb4c4583355960e18f"
 }