payment-kit 1.13.159 → 1.13.161

package/api/src/hooks/pre-flight.ts

@@ -2,13 +2,10 @@ import '@blocklet/sdk/lib/error-handler';
 
 import dotenv from 'dotenv-flow';
 
-import { ensureSqliteBinaryFile } from '../libs/hooks';
-
 dotenv.config({ silent: true });
 
 (async () => {
   try {
-    await ensureSqliteBinaryFile();
     await import('../store/migrate').then((m) => m.default());
     process.exit(0);
   } catch (err) {

package/api/src/index.ts

@@ -24,11 +24,12 @@ import { startPaymentQueue } from './queues/payment';
 import { startRefundQueue } from './queues/refund';
 import { startSubscriptionQueue } from './queues/subscription';
 import routes from './routes';
+import changePaymentHandlers from './routes/connect/change-payment';
+import changePlanHandlers from './routes/connect/change-plan';
 import collectHandlers from './routes/connect/collect';
 import payHandlers from './routes/connect/pay';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
-import updateHandlers from './routes/connect/update';
 import { initialize } from './store/models';
 import { sequelize } from './store/sequelize';
 
@@ -56,7 +57,8 @@ handlers.attach(Object.assign({ app: router }, collectHandlers));
 handlers.attach(Object.assign({ app: router }, payHandlers));
 handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));
-handlers.attach(Object.assign({ app: router }, updateHandlers));
+handlers.attach(Object.assign({ app: router }, changePaymentHandlers));
+handlers.attach(Object.assign({ app: router }, changePlanHandlers));
 
 router.use('/api', routes);
 

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -3,6 +3,7 @@ import pick from 'lodash/pick';
 import pWaitFor from 'p-wait-for';
 import type Stripe from 'stripe';
 
+import { getLock } from '../../../libs/lock';
 import logger from '../../../libs/logger';
 import {
   CheckoutSession,
@@ -72,11 +73,15 @@ export async function syncStripeInvoice(invoice: Invoice) {
 }
 
 export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subscription, client: Stripe) {
+  const lock = getLock(`mirror-stripe-invoice-${stripeInvoice.id}`);
+  await lock.acquire();
+
   const customer = await Customer.findByPk(subscription.customer_id);
   const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
 
   let invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoice.id } });
   if (invoice) {
+    lock.release();
     return invoice;
   }
 
@@ -175,6 +180,7 @@ export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subs
     })
   );
 
+  lock.release();
   return invoice;
 }
 

package/api/src/integrations/stripe/handlers/setup-intent.ts

@@ -1,11 +1,9 @@
 import type Stripe from 'stripe';
 
 import logger from '../../../libs/logger';
-import { CheckoutSession, Subscription, TEventExpanded } from '../../../store/models';
+import { CheckoutSession, SetupIntent, Subscription, TEventExpanded } from '../../../store/models';
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
-  const stripeIntentId = event.data.object.id;
+async function handleSubscriptionOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
   const subscription = await Subscription.findOne({
     where: { 'payment_details.stripe.setup_intent_id': stripeIntentId },
   });
@@ -15,8 +13,6 @@ export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
     return;
   }
 
-  logger.info('received setup intent event', { id: event.id, type: event.type, subscriptionId: subscription.id });
-
   if (event.type === 'setup_intent.succeeded') {
     if (subscription.status === 'incomplete') {
       await subscription.start();
@@ -40,3 +36,54 @@ export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
     // FIXME:
   }
 }
+
+async function handleSetupIntentOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
+  const setupIntent = await SetupIntent.findOne({
+    where: { 'setup_details.stripe.setup_intent_id': stripeIntentId },
+  });
+
+  if (!setupIntent) {
+    logger.warn('local subscription not found for setup intent', { id: event.id, type: event.type, stripeIntentId });
+    return;
+  }
+
+  if (event.type === 'setup_intent.succeeded') {
+    setupIntent.update({
+      status: 'succeeded',
+      last_setup_error: null,
+      payment_method_types: ['stripe'],
+    });
+
+    if (
+      setupIntent.metadata?.subscription_id &&
+      setupIntent.metadata?.from_currency &&
+      setupIntent.metadata?.to_currency
+    ) {
+      const subscription = await Subscription.findByPk(setupIntent.metadata.subscription_id);
+      if (subscription) {
+        await subscription.update({
+          currency_id: setupIntent.currency_id,
+          default_payment_method_id: setupIntent.payment_method_id,
+          payment_settings: {
+            payment_method_types: ['stripe'],
+            payment_method_options: {},
+          },
+        });
+        logger.info('subscription payment changed to stripe on stripe setup intent succeeded', {
+          subscriptionId: subscription.id,
+          setupIntentId: setupIntent.id,
+          stripeIntentId,
+        });
+      }
+    }
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
+  const stripeIntentId = event.data.object.id;
+  logger.info('received setup intent event', { id: event.id, type: event.type, stripeIntentId });
+
+  await handleSubscriptionOnSetupSucceeded(event, stripeIntentId);
+  await handleSetupIntentOnSetupSucceeded(event, stripeIntentId);
+}

package/api/src/integrations/stripe/handlers/subscription.ts

@@ -43,9 +43,11 @@ export async function handleSubscriptionEvent(event: TEventExpanded, _: Stripe)
       return;
     }
 
-    await subscription.update(
-      pick(event.data.object, ['cancel_at', 'cancel_at_period_end', 'canceled_at', 'pause_collection'])
-    );
+    const fields = ['cancel_at', 'cancel_at_period_end', 'canceled_at'];
+    if (subscription.payment_settings?.payment_method_types?.includes('stripe')) {
+      fields.push('pause_collection');
+    }
+    await subscription.update(pick(event.data.object, fields));
     return;
   }
 

package/api/src/integrations/stripe/resource.ts

@@ -192,7 +192,8 @@ export async function ensureStripeSubscription(
   method: PaymentMethod,
   currency: PaymentCurrency,
   items: TLineItemExpanded[],
-  trialInDays: number = 0
+  trialInDays: number = 0,
+  trialEnds: number = 0
 ) {
   const client = method.getStripeClient();
 
@@ -226,12 +227,11 @@ export async function ensureStripeSubscription(
       .filter((x) => x.price.type !== 'recurring')
       .map((x) => ({ price: x.stripePrice.id, quantity: x.quantity }));
 
-    stripeSubscription = await client.subscriptions.create({
+    const props: any = {
       currency: currency.symbol.toLowerCase(),
       customer: customer.id,
       items: recurringItems,
       add_invoice_items: onetimeItems,
-      trial_period_days: trialInDays,
       payment_behavior: 'default_incomplete',
       payment_settings: { save_default_payment_method: 'on_subscription' },
       metadata: {
@@ -239,7 +239,15 @@ export async function ensureStripeSubscription(
         id: internal.id,
       },
       expand: ['latest_invoice.payment_intent', 'pending_setup_intent'],
-    });
+    };
+
+    if (trialInDays) {
+      props.trial_period_days = trialInDays;
+    } else if (trialEnds) {
+      props.trial_end = trialEnds;
+    }
+
+    stripeSubscription = await client.subscriptions.create(props);
     logger.info('stripe subscription created', { local: internal.id, remote: stripeSubscription.id });
 
     await Promise.all(

package/api/src/libs/subscription.ts

@@ -16,7 +16,7 @@ import {
 } from '../store/models';
 import dayjs from './dayjs';
 import logger from './logger';
-import { getPriceUintAmountByCurrency, getRecurringPeriod } from './session';
+import { getPriceCurrencyOptions, getPriceUintAmountByCurrency, getRecurringPeriod } from './session';
 import { getConnectQueryParam } from './util';
 
 export function getCustomerSubscriptionPageUrl({
@@ -315,3 +315,14 @@ export function formatSubscriptionProduct(items: TLineItemExpanded[], maxLength
     names.slice(0, maxLength).join(', ') + (names.length > maxLength ? ` and ${names.length - maxLength} more` : '')
   );
 }
+
+export async function canChangePaymentMethod(subscriptionId: string) {
+  const item = await SubscriptionItem.findOne({ where: { subscription_id: subscriptionId } });
+  const expanded = await Price.findOne({ where: { id: item!.price_id } });
+  return expanded && getPriceCurrencyOptions(expanded).length > 1;
+}
+
+export async function expandSubscriptionItems(subscriptionId: string) {
+  const items = await SubscriptionItem.findAll({ where: { subscription_id: subscriptionId } });
+  return Price.expand(items.map((x) => x.toJSON()));
+}

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

@@ -615,7 +615,6 @@ router.put('/:id/submit', user, ensureCheckoutSessionOpen, async (req, res) => {
           intent: setupIntent.id,
         });
       } else {
-        // ensure payment intent
         setupIntent = await SetupIntent.create({
           livemode: !!checkoutSession.livemode,
           customer_id: customer.id,

package/api/src/routes/connect/change-payment.ts

@@ -0,0 +1,106 @@
+import { toTypeInfo } from '@arcblock/did';
+import type { Transaction } from '@ocap/client';
+import { fromPublicKey } from '@ocap/wallet';
+
+import type { CallbackArgs } from '../../libs/auth';
+import { getGasPayerExtra } from '../../libs/payment';
+import { getTxMetadata } from '../../libs/util';
+import type { TLineItemExpanded } from '../../store/models';
+import { ensureChangePaymentContext, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
+
+export default {
+  action: 'change-payment',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureChangePaymentContext(extraParams.subscriptionId);
+      return getAuthPrincipalClaim(paymentMethod, 'continue');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, paymentMethod, paymentCurrency } = await ensureChangePaymentContext(subscriptionId);
+
+    if (paymentMethod.type === 'arcblock') {
+      // @ts-ignore
+      const items = subscription!.items as TLineItemExpanded[];
+
+      return {
+        signature: await getDelegationTxClaim({
+          mode: 'setup',
+          userDid,
+          userPk,
+          nonce: subscription!.id,
+          data: getTxMetadata({ subscriptionId: subscription!.id }),
+          paymentCurrency,
+          paymentMethod,
+          trial: false,
+          items,
+        }),
+      };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+
+  onAuth: async ({ userDid, userPk, claims, extraParams }: CallbackArgs) => {
+    const { subscriptionId } = extraParams;
+    const { subscription, setupIntent, paymentCurrency, paymentMethod } = await ensureChangePaymentContext(
+      subscriptionId
+    );
+
+    if (paymentMethod.type === 'arcblock') {
+      await subscription?.update({
+        payment_settings: {
+          payment_method_types: ['arcblock'],
+          payment_method_options: {
+            arcblock: { payer: userDid },
+          },
+        },
+      });
+
+      const client = paymentMethod.getOcapClient();
+      const claim = claims.find((x) => x.type === 'signature');
+
+      // execute the delegate tx
+      const tx: Partial<Transaction> = client.decodeTx(claim.origin);
+      tx.signature = claim.sig;
+
+      // @ts-ignore
+      const { buffer } = await client.encodeDelegateTx({ tx });
+      const txHash = await client.sendDelegateTx(
+        // @ts-ignore
+        { tx, wallet: fromPublicKey(userPk, toTypeInfo(userDid)) },
+        getGasPayerExtra(buffer)
+      );
+
+      await setupIntent.update({
+        status: 'succeeded',
+        last_setup_error: null,
+        payment_method_types: ['arcblock'],
+        payment_method_options: {
+          arcblock: { payer: userDid },
+        },
+        setup_details: {
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
+        },
+      });
+
+      await subscription?.update({
+        currency_id: paymentCurrency.id,
+        default_payment_method_id: paymentMethod.id,
+        payment_settings: {
+          payment_method_types: [paymentMethod.type],
+          payment_method_options: {},
+        },
+      });
+
+      return { hash: txHash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

package/api/src/routes/connect/{update.ts → change-plan.ts}

@@ -11,7 +11,7 @@ import type { TLineItemExpanded } from '../../store/models';
 import { ensureSubscription, getAuthPrincipalClaim, getDelegationTxClaim } from './shared';
 
 export default {
-  action: 'update',
+  action: 'change-plan',
   authPrincipal: false,
   claims: {
     authPrincipal: async ({ extraParams }: CallbackArgs) => {

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

@@ -87,14 +87,16 @@ export default {
 
       await setupIntent.update({
         status: 'succeeded',
-        payment_method_types: ['arcblock'],
         last_setup_error: null,
+        payment_method_types: ['arcblock'],
         payment_method_options: {
           arcblock: { payer: userDid },
         },
         setup_details: {
-          tx_hash: txHash,
-          payer: userDid,
+          arcblock: {
+            tx_hash: txHash,
+            payer: userDid,
+          },
         },
       });
 

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

@@ -11,12 +11,11 @@ import dayjs from '../../libs/dayjs';
 import logger from '../../libs/logger';
 import { getTokenLimitsForDelegation } from '../../libs/payment';
 import {
-  expandLineItems,
   getFastCheckoutAmount,
   getPriceUintAmountByCurrency,
   getStatementDescriptor,
 } from '../../libs/session';
-import { getSubscriptionItemPrice } from '../../libs/subscription';
+import { expandSubscriptionItems, getSubscriptionItemPrice } from '../../libs/subscription';
 import type { TLineItemExpanded } from '../../store/models';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { Customer } from '../../store/models/customer';
@@ -26,7 +25,6 @@ import { PaymentCurrency } from '../../store/models/payment-currency';
 import { PaymentIntent } from '../../store/models/payment-intent';
 import { PaymentMethod } from '../../store/models/payment-method';
 import { Price } from '../../store/models/price';
-import { Product } from '../../store/models/product';
 import { SetupIntent } from '../../store/models/setup-intent';
 import { Subscription } from '../../store/models/subscription';
 import { SubscriptionItem } from '../../store/models/subscription-item';
@@ -709,15 +707,8 @@ export async function ensureSubscription(subscriptionId: string): Promise<Result
     throw new Error(`Payment method ${paymentMethod.type} should not be here`);
   }
 
-  const items = (await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } })).map((x) =>
-    x.toJSON()
-  );
-  const products = (await Product.findAll()).map((x) => x.toJSON());
-  const prices = (await Price.findAll()).map((x) => x.toJSON());
-  // @ts-ignore
-  expandLineItems(items, products, prices);
   // @ts-ignore
-  subscription.items = await Price.expand(items);
+  subscription.items = await expandSubscriptionItems(subscription.id);
 
   return {
     // @ts-ignore
@@ -729,3 +720,51 @@ export async function ensureSubscription(subscriptionId: string): Promise<Result
     invoice,
   };
 }
+
+export async function ensureChangePaymentContext(subscriptionId: string) {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error(`Subscription not found: ${subscriptionId}`);
+  }
+
+  const context = subscription.metadata?.changePayment || {};
+  if (!context || !context.setup_intent_id) {
+    throw new Error(`Change payment context not found: ${subscriptionId}`);
+  }
+
+  const setupIntent = await SetupIntent.findByPk(context.setup_intent_id);
+  if (!setupIntent) {
+    throw new Error(`SetupIntent not found for subscription payment change ${subscriptionId}`);
+  }
+  if (setupIntent.status === 'succeeded') {
+    throw new Error(`SetupIntent completed for subscription payment change ${subscriptionId}`);
+  }
+
+  const paymentCurrencyId = setupIntent.currency_id;
+  const paymentMethodId = setupIntent.payment_method_id;
+
+  const [paymentMethod, paymentCurrency] = await Promise.all([
+    PaymentMethod.findByPk(paymentMethodId),
+    PaymentCurrency.findByPk(paymentCurrencyId),
+  ]);
+  if (!paymentMethod) {
+    throw new Error(`Payment method not found for SetupIntent ${setupIntent.id}`);
+  }
+  if (!paymentCurrency) {
+    throw new Error(`Payment currency not found for SetupIntent ${setupIntent.id}`);
+  }
+
+  if (['arcblock', 'ethereum'].includes(paymentMethod.type) === false) {
+    throw new Error(`Payment method ${paymentMethod.type} should not be here`);
+  }
+
+  // @ts-ignore
+  subscription.items = await expandSubscriptionItems(subscription.id);
+
+  return {
+    subscription,
+    setupIntent,
+    paymentMethod,
+    paymentCurrency,
+  };
+}

package/api/src/routes/invoices.ts

@@ -1,12 +1,14 @@
 import { isValid } from '@arcblock/did';
 import { Router } from 'express';
 import Joi from 'joi';
+import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
 import { syncStripeInvoice } from '../integrations/stripe/handlers/invoice';
 import { getWhereFromKvQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
 import { expandLineItems } from '../libs/session';
+import { formatMetadata } from '../libs/util';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
 import { InvoiceItem } from '../store/models/invoice-item';
@@ -18,6 +20,7 @@ import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
 
 const router = Router();
+const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
 const authMine = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'], mine: true });
 const authPortal = authenticate<Invoice>({
   component: true,
@@ -177,4 +180,25 @@ router.get('/:id', authPortal, async (req, res) => {
   }
 });
 
+// eslint-disable-next-line consistent-return
+router.put('/:id', authAdmin, async (req, res) => {
+  try {
+    const doc = await Invoice.findByPk(req.params.id as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'Invoice not found' });
+    }
+
+    const raw = pick(req.body, ['metadata']);
+    if (raw.metadata) {
+      raw.metadata = formatMetadata(raw.metadata);
+    }
+
+    await doc.update(raw);
+    res.json(doc);
+  } catch (err) {
+    console.error(err);
+    res.json(null);
+  }
+});
+
 export default router;

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

@@ -1,11 +1,13 @@
 import { isValid } from '@arcblock/did';
 import { Router } from 'express';
 import Joi from 'joi';
+import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
 import { syncStripPayment } from '../integrations/stripe/handlers/payment-intent';
 import { getWhereFromKvQuery, getWhereFromQuery } from '../libs/api';
 import { authenticate } from '../libs/security';
+import { formatMetadata } from '../libs/util';
 import { CheckoutSession } from '../store/models/checkout-session';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
@@ -15,6 +17,7 @@ import { PaymentMethod } from '../store/models/payment-method';
 import { Subscription } from '../store/models/subscription';
 
 const router = Router();
+const authAdmin = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
 const authMine = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'], mine: true });
 const authPortal = authenticate<PaymentIntent>({
   component: true,
@@ -178,4 +181,25 @@ router.get('/:id', authPortal, async (req, res) => {
   }
 });
 
+// eslint-disable-next-line consistent-return
+router.put('/:id', authAdmin, async (req, res) => {
+  try {
+    const doc = await PaymentIntent.findByPk(req.params.id as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'PaymentIntent not found' });
+    }
+
+    const raw = pick(req.body, ['metadata']);
+    if (raw.metadata) {
+      raw.metadata = formatMetadata(raw.metadata);
+    }
+
+    await doc.update(raw);
+    res.json(doc);
+  } catch (err) {
+    console.error(err);
+    res.json(null);
+  }
+});
+
 export default router;

package/api/src/routes/refunds.ts

@@ -1,9 +1,11 @@
 /* eslint-disable consistent-return */
 import { Router } from 'express';
 import Joi from 'joi';
+import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
 import { authenticate } from '../libs/security';
+import { formatMetadata } from '../libs/util';
 import {
   Customer,
   Invoice,
@@ -15,6 +17,7 @@ import {
 } from '../store/models';
 
 const router = Router();
+const authAdmin = authenticate<Invoice>({ component: true, roles: ['owner', 'admin'] });
 const auth = authenticate<Invoice>({
   component: true,
   roles: ['owner', 'admin'],
@@ -119,4 +122,25 @@ router.get('/:id', auth, async (req, res) => {
   return res.status(404).json(null);
 });
 
+// eslint-disable-next-line consistent-return
+router.put('/:id', authAdmin, async (req, res) => {
+  try {
+    const doc = await Refund.findByPk(req.params.id as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'Refund not found' });
+    }
+
+    const raw = pick(req.body, ['metadata']);
+    if (raw.metadata) {
+      raw.metadata = formatMetadata(raw.metadata);
+    }
+
+    await doc.update(raw);
+    res.json(doc);
+  } catch (err) {
+    console.error(err);
+    res.json(null);
+  }
+});
+
 export default router;