payment-kit 1.25.6 → 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/routes/subscriptions.ts

@@ -3142,4 +3142,165 @@ router.post('/:id/update-stripe-payment-method', authPortal, async (req, res) =>
   }
 });
 
+/**
+ * Fix subscription after payment method migration from Stripe to non-Stripe
+ * This API is used to fix legacy subscriptions that were migrated but the migration
+ * was incomplete (missing payment_settings/payment_details updates)
+ *
+ * This API will:
+ * 1. Pause the Stripe subscription (if not already paused)
+ * 2. Update payment_settings to use arcblock
+ * 3. Update payment_details to add arcblock info
+ * 4. Recalculate cancel_at if needed
+ */
+router.put('/:id/fix-stripe-migration', auth, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+
+    const stripeSubscriptionId = subscription.payment_details?.stripe?.subscription_id;
+    if (!stripeSubscriptionId) {
+      return res.status(400).json({ error: 'Subscription does not have Stripe subscription_id' });
+    }
+
+    // Get customer for payer DID
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+
+    // Find arcblock payment method
+    const arcblockMethod = await PaymentMethod.findOne({
+      where: { type: 'arcblock', livemode: subscription.livemode },
+    });
+    if (!arcblockMethod) {
+      return res.status(400).json({ error: 'ArcBlock payment method not found' });
+    }
+
+    // Find Stripe payment method to pause subscription
+    const stripeMethod = await PaymentMethod.findOne({
+      where: { type: 'stripe', livemode: subscription.livemode },
+    });
+
+    // 1. Pause Stripe subscription if not already paused
+    let stripePaused = false;
+    if (stripeMethod) {
+      try {
+        const client = stripeMethod.getStripeClient();
+        const stripeSubscription = await client.subscriptions.retrieve(stripeSubscriptionId);
+        if (stripeSubscription && !stripeSubscription.pause_collection) {
+          await client.subscriptions.update(stripeSubscriptionId, {
+            pause_collection: { behavior: 'void' },
+          });
+          stripePaused = true;
+          logger.info('Stripe subscription paused during fix', {
+            subscriptionId: subscription.id,
+            stripeSubscriptionId,
+          });
+        } else if (stripeSubscription?.pause_collection) {
+          logger.info('Stripe subscription already paused', {
+            subscriptionId: subscription.id,
+            stripeSubscriptionId,
+          });
+        }
+      } catch (stripeErr) {
+        logger.warn('Failed to pause Stripe subscription during fix, continuing anyway', {
+          subscriptionId: subscription.id,
+          stripeSubscriptionId,
+          error: stripeErr,
+        });
+      }
+    }
+
+    const updates: Partial<TSubscription> = {};
+
+    // 2. Update payment_settings to use arcblock (matching change-payment behavior)
+    updates.payment_settings = {
+      payment_method_types: ['arcblock'],
+      payment_method_options: {
+        arcblock: { payer: customer.did },
+      },
+    };
+
+    // 3. Update payment_details.arcblock.payer if not already present
+    if (!subscription.payment_details?.arcblock?.payer) {
+      const existingArcblock = subscription.payment_details?.arcblock;
+      updates.payment_details = {
+        ...subscription.payment_details,
+        arcblock: {
+          ...existingArcblock,
+          payer: customer.did,
+          type: existingArcblock?.type || 'delegate',
+          tx_hash: existingArcblock?.tx_hash || '',
+        },
+      };
+    }
+
+    // 4. Update default_payment_method_id to arcblock
+    updates.default_payment_method_id = arcblockMethod.id;
+
+    // 5. Recalculate cancel_at if subscription has cancelation_details but no cancel_at
+    if (req.body.recalculate_cancel_at !== false) {
+      if (subscription.cancelation_details && !subscription.cancel_at) {
+        const daysUntilCancel = subscription.days_until_cancel || 0;
+        if (daysUntilCancel > 0) {
+          const dueUnit = 24 * 60 * 60; // 1 day in seconds
+          updates.cancel_at = subscription.current_period_start + daysUntilCancel * dueUnit;
+        } else {
+          updates.cancel_at_period_end = true;
+          updates.cancel_at = subscription.current_period_end;
+        }
+      }
+    }
+
+    // Allow manual override of cancel_at
+    if (typeof req.body.cancel_at === 'number') {
+      updates.cancel_at = req.body.cancel_at;
+    }
+
+    await subscription.update(updates);
+
+    logger.info('Subscription stripe migration fixed', {
+      subscriptionId: subscription.id,
+      customerDid: customer.did,
+      updates: {
+        ...updates,
+        payment_details: '(updated)',
+      },
+      stripePaused,
+      stripeSubscriptionId,
+    });
+
+    // Reload subscription to return updated data
+    await subscription.reload();
+
+    return res.json({
+      success: true,
+      stripePaused,
+      subscription: pick(subscription, [
+        'id',
+        'status',
+        'cancel_at',
+        'cancel_at_period_end',
+        'canceled_at',
+        'cancelation_details',
+        'payment_details',
+        'payment_settings',
+        'default_payment_method_id',
+        'days_until_cancel',
+        'current_period_start',
+        'current_period_end',
+      ]),
+    });
+  } catch (err) {
+    logger.error('Failed to fix subscription stripe migration', {
+      error: err,
+      subscriptionId: req.params.id,
+    });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 export default router;

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.25.6",
+  "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.6",
-    "@blocklet/payment-react": "1.25.6",
-    "@blocklet/payment-vendor": "1.25.6",
+    "@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.6",
+    "@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": "8a1d87eed8aaa803f29b7c3c69652f2e0c467058"
+  "gitHead": "b40c46bcf52d4c1758bb10eb4c4583355960e18f"
 }