payment-kit 1.19.0 → 1.19.2

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

@@ -38,6 +38,7 @@ import {
   getOneTimeLineItems,
   getCheckoutSessionSubscriptionIds,
   getSubscriptionLineItems,
+  isCreditMeteredLineItems,
 } from '../libs/session';
 import { getDaysUntilCancel, getDaysUntilDue, getSubscriptionTrialSetup } from '../libs/subscription';
 import {
@@ -78,6 +79,7 @@ import { paymentQueue } from '../queues/payment';
 import { invoiceQueue } from '../queues/invoice';
 import { ensureInvoiceForCheckout, ensureInvoicesForSubscriptions } from './connect/shared';
 import {
+  isCreditGrantSufficientForPayment,
   isCreditSufficientForPayment,
   isDelegationSufficientForPayment,
   SufficientForPaymentResult,
@@ -616,6 +618,8 @@ async function processSubscriptionFastCheckout({
   success: boolean;
   invoices?: Invoice[];
   message?: string;
+  token?: { address: string; balance: string };
+  amount?: string;
 }> {
   try {
     const primarySubscription = subscriptions.find((x) => x.metadata?.is_primary_subscription) || subscriptions[0];
@@ -629,12 +633,17 @@ async function processSubscriptionFastCheckout({
       .reduce((sum: BN, amt: string) => sum.add(new BN(amt)), new BN('0'))
       .toString();
 
+    let validAmount = totalAmount;
+    if (totalAmount === '0' && paymentCurrency.isCredit()) {
+      validAmount = '1';
+    }
     const delegationCheck = await isDelegationSufficientForPayment({
       paymentMethod,
       paymentCurrency,
       userDid: customer.did,
-      amount: totalAmount,
+      amount: validAmount,
       delegatorAmounts: subscriptionAmounts,
+      lineItems,
     });
 
     if (!delegationCheck.sufficient) {
@@ -646,6 +655,8 @@ async function processSubscriptionFastCheckout({
       return {
         success: false,
         message: `Insufficient delegation or insufficient balance: ${delegationCheck.reason}`,
+        token: delegationCheck.token,
+        amount: totalAmount,
       };
     }
 
@@ -658,6 +669,33 @@ async function processSubscriptionFastCheckout({
     if (executePayment) {
       // Update payment settings for all subscriptions
       await Promise.all(subscriptions.map((sub) => sub.update({ payment_settings: paymentSettings })));
+      if (paymentCurrency.isCredit()) {
+        // skip invoice creation for credit subscriptions
+        checkoutSession.update({
+          status: 'complete',
+          payment_status: 'paid',
+        });
+        await Promise.all(
+          subscriptions.map(async (sub) => {
+            await sub.update({
+              payment_settings: paymentSettings,
+              status: sub.trial_end ? 'trialing' : 'active',
+              payment_details: {
+                [paymentMethod.type]: {
+                  type: 'credit',
+                  payer: customer.did,
+                },
+              },
+            });
+            addSubscriptionJob(sub, 'cycle', false, sub.trial_end);
+          })
+        );
+        return {
+          success: true,
+          invoices: [],
+          token: delegationCheck.token,
+        };
+      }
 
       // Create invoices for all subscriptions
       const { invoices } = await ensureInvoicesForSubscriptions({
@@ -686,11 +724,15 @@ async function processSubscriptionFastCheckout({
       return {
         success: true,
         invoices,
+        token: delegationCheck.token,
+        amount: totalAmount,
       };
     }
     return {
       success: true,
       invoices: [],
+      token: delegationCheck.token,
+      amount: totalAmount,
     };
   } catch (error) {
     logger.error('Error processing subscription fast checkout', {
@@ -701,6 +743,8 @@ async function processSubscriptionFastCheckout({
     return {
       success: false,
       message: error.message,
+      token: { address: paymentCurrency.id, balance: '0' },
+      amount: '0',
     };
   }
 }
@@ -754,7 +798,9 @@ export async function startCheckoutSessionFromPaymentLink(id: string, req: Reque
     }
 
     // Settings priority: PaymentLink.subscription_data > req.query > environments
-    const protectedSettings: Partial<SubscriptionData> = {};
+    const protectedSettings: Partial<SubscriptionData> = {
+      no_stake: isCreditMeteredLineItems(items) ? true : link.subscription_data?.no_stake,
+    };
     if (link.subscription_data?.min_stake_amount) {
       protectedSettings.min_stake_amount = getMinStakeAmount(link.subscription_data);
     }
@@ -964,6 +1010,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     }
 
     const checkoutSession = req.doc as CheckoutSession;
+    logger.info('---checkoutSession---', checkoutSession.line_items);
     if (checkoutSession.line_items) {
       try {
         await validateInventory(checkoutSession.line_items);
@@ -1231,6 +1278,11 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
     let canFastPay = isPayment && canPayWithDelegation(paymentIntent?.beneficiaries || []);
     let fastPayInfo = null;
     let delegation: SufficientForPaymentResult | null = null;
+    let creditSufficient = false;
+
+    const canFastPayForSubscription =
+      paymentCurrency.isCredit() ||
+      (checkoutSession.mode === 'subscription' && checkoutSession.subscription_data?.no_stake);
     if (isPayment && paymentIntent && canFastPay) {
       // if we can complete purchase without any wallet interaction
       delegation = await isDelegationSufficientForPayment({
@@ -1246,11 +1298,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           payer: customer.did,
         };
       }
-    } else if (
-      paymentMethod.type === 'arcblock' &&
-      checkoutSession.mode === 'subscription' &&
-      checkoutSession.subscription_data?.no_stake
-    ) {
+    } else if (paymentMethod.type === 'arcblock' && canFastPayForSubscription) {
       // if we can complete purchase without any wallet interaction
       const result = await processSubscriptionFastCheckout({
         checkoutSession,
@@ -1269,6 +1317,8 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         logger.warn(`Fast checkout processing failed: ${result.message}`, {
           checkoutSessionId: checkoutSession.id,
         });
+
+        creditSufficient = false;
       } else {
         delegation = {
           sufficient: true,
@@ -1276,9 +1326,13 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
         canFastPay = true;
         fastPayInfo = {
           type: 'delegation',
-          amount: fastCheckoutAmount,
+          amount: result?.amount || '0',
           payer: customer.did,
+          token: result?.token,
         };
+        if (paymentCurrency.isCredit()) {
+          creditSufficient = true;
+        }
       }
     }
 
@@ -1411,6 +1465,7 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
       delegation: canFastPay ? delegation : null,
       balance: canFastPay ? balance : null,
       fastPayInfo,
+      creditSufficient,
     });
   } catch (err) {
     logger.error('Error submitting checkout session', {
@@ -1587,12 +1642,78 @@ router.post('/:id/fast-checkout-confirm', user, ensureCheckoutSessionOpen, async
       customer,
       amount: fastCheckoutAmount,
     });
+    // Check if this is a credit payment
+    const isCredit = paymentCurrency.isCredit();
 
     const isPayment = checkoutSession.mode === 'payment';
     let fastPaid = false;
     let canFastPay = isPayment && canPayWithDelegation(paymentIntent?.beneficiaries || []);
     let delegation: SufficientForPaymentResult | null = null;
-    if (isPayment && paymentIntent && canFastPay) {
+
+    // Handle credit payment directly
+    if (isCredit) {
+      const result = await isCreditGrantSufficientForPayment({
+        paymentMethod,
+        paymentCurrency,
+        userDid: customer.did,
+        amount: fastCheckoutAmount,
+      });
+      if (!result.sufficient) {
+        return res.status(400).json({
+          code: 'CREDIT_INSUFFICIENT',
+          error: result.reason,
+          sufficient: result.sufficient,
+        });
+      }
+      fastPaid = true;
+      // For credit payments, we use the existing subscription fast checkout flow
+      // but skip the actual payment processing
+      if (['setup', 'subscription'].includes(checkoutSession.mode)) {
+        const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+        const subscriptions = await Subscription.findAll({ where: { id: subscriptionIds } });
+
+        if (checkoutSession.mode === 'setup') {
+          const setupIntent = await SetupIntent.findByPk(checkoutSession.setup_intent_id);
+          if (!setupIntent) {
+            throw new Error('SetupIntent not found for checkoutSession');
+          }
+          await setupIntent.update({
+            status: 'succeeded',
+            last_setup_error: null,
+            setup_details: {
+              [paymentMethod.type]: {
+                type: 'credit',
+                payer: customer.did,
+              },
+            },
+            ...paymentSettings,
+          });
+        }
+        checkoutSession.update({
+          status: 'complete',
+          payment_status: 'paid',
+        });
+        await Promise.all(
+          subscriptions.map(async (sub) => {
+            await sub.update({
+              payment_settings: paymentSettings,
+              status: sub.trial_end ? 'trialing' : 'active',
+              payment_details: {
+                [paymentMethod.type]: {
+                  type: 'credit',
+                  payer: customer.did,
+                },
+              },
+            });
+            addSubscriptionJob(sub, 'cycle', false, sub.trial_end);
+          })
+        );
+        delegation = {
+          sufficient: true,
+        };
+        canFastPay = true;
+      }
+    } else if (isPayment && paymentIntent && canFastPay) {
       // if we can complete purchase without any wallet interaction
       delegation = await isDelegationSufficientForPayment({
         paymentMethod,
@@ -1764,6 +1885,33 @@ router.put('/:id/downsell', user, ensureCheckoutSessionOpen, async (req, res) =>
   }
 });
 
+// adjust quantity
+router.put('/:id/adjust-quantity', user, ensureCheckoutSessionOpen, async (req, res) => {
+  try {
+    const checkoutSession = req.doc as CheckoutSession;
+    const { itemId, quantity } = req.body;
+    if (!checkoutSession.line_items) {
+      return res.status(400).json({ error: 'Line items not found' });
+    }
+
+    const item = checkoutSession.line_items.find((x) => x.price_id === itemId);
+    if (!item) {
+      return res.status(400).json({ error: 'Item not found' });
+    }
+    const items = cloneDeep(checkoutSession.line_items);
+    const targetItem = items.find((x) => x.price_id === itemId);
+    if (targetItem) {
+      targetItem.quantity = quantity;
+    }
+    await validateInventory(items, true);
+    await checkoutSession.update({ line_items: items });
+    const lineItems = await Price.expand(checkoutSession.line_items);
+    res.json({ ...checkoutSession.toJSON(), line_items: lineItems });
+  } catch (err) {
+    logger.error(err);
+    res.status(400).json({ error: err.message });
+  }
+});
 // eslint-disable-next-line consistent-return
 router.put('/:id/expire', auth, ensureCheckoutSessionOpen, async (req, res) => {
   const doc = req.doc as CheckoutSession;

package/api/src/routes/connect/shared.ts

@@ -1063,8 +1063,9 @@ export async function ensureSubscription(subscriptionId: string): Promise<Result
   if (!subscription) {
     throw new Error(`Subscription not found: ${subscriptionId}`);
   }
-  if (subscription.status !== 'past_due') {
-    throw new Error(`Subscription ${subscriptionId} is not in past_due status`);
+
+  if (subscription.isActive() === false) {
+    throw new Error(`Subscription ${subscriptionId} is not active`);
   }
 
   const paymentCurrencyId = subscription.currency_id;

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

@@ -0,0 +1,241 @@
+import { Router } from 'express';
+import Joi from 'joi';
+import { fromTokenToUnit } from '@ocap/util';
+
+import { literal, OrderItem } from 'sequelize';
+import pick from 'lodash/pick';
+import { createListParamSchema, getOrder, getWhereFromKvQuery, MetadataSchema } from '../libs/api';
+import logger from '../libs/logger';
+import { authenticate } from '../libs/security';
+import { CreditGrant, Customer, PaymentCurrency, Price, Subscription } from '../store/models';
+import { createCreditGrant } from '../libs/credit-grant';
+import { getMeterPriceIdsFromSubscription } from '../libs/subscription';
+
+const router = Router();
+const auth = authenticate<CreditGrant>({ component: true, roles: ['owner', 'admin'] });
+const authMine = authenticate<CreditGrant>({ component: true, roles: ['owner', 'admin'], mine: true });
+const authPortal = authenticate<CreditGrant>({
+  component: true,
+  roles: ['owner', 'admin'],
+  record: {
+    // @ts-ignore
+    model: CreditGrant,
+    field: 'customer_id',
+  },
+});
+const creditGrantSchema = Joi.object({
+  amount: Joi.number().required(),
+  currency_id: Joi.string().max(15).optional(),
+  customer_id: Joi.string().max(18).required(),
+  name: Joi.string().max(255).optional(),
+  category: Joi.string().valid('paid', 'promotional').required(),
+  priority: Joi.number().integer().min(0).max(100).default(50),
+  effective_at: Joi.number().integer().optional(),
+  expires_at: Joi.number().integer().optional(),
+  metadata: MetadataSchema,
+  applicability_config: Joi.object({
+    scope: Joi.object({
+      price_type: Joi.string().valid('metered').optional(),
+      prices: Joi.array().items(Joi.string()).optional(),
+    }).optional(),
+  }).optional(),
+});
+
+const listSchema = createListParamSchema<{
+  customer_id?: string;
+  currency_id?: string;
+  status?: string;
+  livemode?: boolean;
+  q?: string;
+}>({
+  customer_id: Joi.string().optional(),
+  currency_id: Joi.string().optional(),
+  status: Joi.string().optional(),
+  livemode: Joi.boolean().optional(),
+  q: Joi.string().optional(),
+});
+
+async function expandScopePrices(creditGrant: CreditGrant) {
+  const scope = creditGrant.applicability_config?.scope;
+  if (scope && scope.prices) {
+    const expandedItems = await Price.expand(
+      scope.prices.map((x) => ({ id: x, price_id: x, quantity: 1 })),
+      { product: true }
+    );
+    return expandedItems;
+  }
+  return [];
+}
+
+router.get('/', authMine, async (req, res) => {
+  try {
+    const { page, pageSize, ...query } = await listSchema.validateAsync(req.query, { stripUnknown: true });
+    const where = getWhereFromKvQuery(query.q);
+    if (query.customer_id) {
+      where.customer_id = query.customer_id;
+    }
+    if (query.currency_id) {
+      where.currency_id = query.currency_id;
+    }
+    if (query.status) {
+      where.status = typeof query.status === 'string' ? query.status.split(',') : query.status;
+    }
+    if (typeof query.livemode === 'boolean') {
+      where.livemode = query.livemode;
+    }
+
+    const order: OrderItem[] = getOrder(req.query);
+    // 默认granted 、pending、depleted 排序
+    order.unshift([literal("CASE status WHEN 'granted' THEN 1 WHEN 'pending' THEN 2 ELSE 3 END"), 'ASC']);
+
+    const { rows: list, count } = await CreditGrant.findAndCountAll({
+      where,
+      order,
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      include: [
+        { model: Customer, as: 'customer' },
+        { model: PaymentCurrency, as: 'paymentCurrency' },
+      ],
+    });
+
+    res.json({ count, list, paging: { page, pageSize } });
+  } catch (err) {
+    logger.error('Error listing credit grants', err);
+    res.status(400).json({ error: err.message });
+  }
+});
+
+router.get('/summary', authMine, async (req, res) => {
+  try {
+    const customerId = req.query.customer_id;
+    if (!customerId) {
+      return res.status(400).json({ error: 'customer_id is required' });
+    }
+
+    const customer = await Customer.findByPkOrDid(customerId as string);
+    if (!customer) {
+      return res.status(404).json({ error: `Customer ${customerId} not found` });
+    }
+
+    const { subscription_id: subscriptionId } = req.query;
+    if (subscriptionId && typeof subscriptionId !== 'string') {
+      return res.status(400).json({ error: 'subscription_id must be a string' });
+    }
+
+    let priceIds: string[] = [];
+    if (subscriptionId) {
+      const subscription = await Subscription.findByPk(subscriptionId);
+      if (!subscription) {
+        return res.status(404).json({ error: 'Subscription not found' });
+      }
+      priceIds = await getMeterPriceIdsFromSubscription(subscription);
+    }
+
+    const result = await CreditGrant.getEffectiveCreditSummary({
+      customerId: customer.id,
+      priceIds,
+    });
+
+    return res.json(result);
+  } catch (err: any) {
+    logger.error('get credit balance failed', { error: err.message, customerId: req.params.customer_id });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+router.get('/:id', authPortal, async (req, res) => {
+  const creditGrant = await CreditGrant.findByPk(req.params.id, {
+    include: [
+      { model: Customer, as: 'customer' },
+      { model: PaymentCurrency, as: 'paymentCurrency' },
+    ],
+  });
+  if (!creditGrant) {
+    return res.status(404).json({ error: `Credit grant ${req.params.id} not found` });
+  }
+  const expandedPrices = await expandScopePrices(creditGrant);
+  return res.json({
+    ...creditGrant.toJSON(),
+    items: expandedPrices,
+  });
+});
+
+router.post('/', auth, async (req, res) => {
+  try {
+    const { error } = creditGrantSchema.validate(req.body);
+    if (error) {
+      return res.status(400).json({ error: `Credit grant create request invalid: ${error.message}` });
+    }
+
+    // 获取币种信息用于金额转换
+    const currencyId = req.body.currency_id;
+    if (!currencyId) {
+      return res.status(400).json({ error: 'currency_id is required' });
+    }
+
+    const paymentCurrency = await PaymentCurrency.findByPk(currencyId);
+    if (!paymentCurrency) {
+      return res.status(404).json({ error: `PaymentCurrency ${currencyId} not found` });
+    }
+
+    const customer = await Customer.findByPkOrDid(req.body.customer_id);
+    if (!customer) {
+      return res.status(404).json({ error: `Customer ${req.body.customer_id} not found` });
+    }
+
+    const unitAmount = fromTokenToUnit(req.body.amount, paymentCurrency.decimal).toString();
+    let applicabilityConfig = req.body.applicability_config;
+    if (!req.body.applicability_config || !req.body.applicability_config.scope?.prices) {
+      applicabilityConfig = {
+        scope: {
+          price_type: 'metered',
+        },
+      };
+    }
+
+    const creditGrant = await createCreditGrant({
+      amount: unitAmount,
+      currency_id: currencyId,
+      customer_id: req.body.customer_id,
+      name: req.body.name,
+      category: req.body.category,
+      priority: req.body.priority,
+      effective_at: req.body.effective_at,
+      expires_at: req.body.expires_at,
+      applicability_config: applicabilityConfig,
+      metadata: req.body.metadata,
+      livemode: req.livemode,
+      created_via: req.user?.via || 'api',
+      created_by: req.user?.did,
+    });
+
+    return res.json({
+      ...creditGrant.toJSON(),
+      customer,
+      paymentCurrency,
+    });
+  } catch (err: any) {
+    logger.error('create credit grant failed', { error: err.message, request: req.body });
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+const updateMetadataSchema = Joi.object({
+  metadata: MetadataSchema,
+});
+
+router.put('/:id', auth, async (req, res) => {
+  const creditGrant = await CreditGrant.findByPk(req.params.id);
+  if (!creditGrant) {
+    return res.status(404).json({ error: `Credit grant ${req.params.id} not found` });
+  }
+  const { error } = updateMetadataSchema.validate(pick(req.body, 'metadata'));
+  if (error) {
+    return res.status(400).json({ error: `Credit grant update request invalid: ${error.message}` });
+  }
+  await creditGrant.update({ metadata: req.body.metadata });
+  return res.json({ success: true });
+});
+
+export default router;