payment-kit 1.13.210 → 1.13.211

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

@@ -99,42 +99,48 @@ export default {
     }
 
     if (paymentMethod.type === 'arcblock') {
-      const paymentSettings = {
-        payment_method_types: ['arcblock'],
-        payment_method_options: {
-          arcblock: { payer: userDid },
-        },
-      };
-      await setupIntent.update({ status: 'processing' });
-      await subscription.update({ payment_settings: paymentSettings });
-      if (invoice) {
-        await invoice.update({ payment_settings: paymentSettings });
-      }
+      try {
+        const paymentSettings = {
+          payment_method_types: ['arcblock'],
+          payment_method_options: {
+            arcblock: { payer: userDid },
+          },
+        };
+        await setupIntent.update({ status: 'processing' });
+        await subscription.update({ payment_settings: paymentSettings });
+        if (invoice) {
+          await invoice.update({ payment_settings: paymentSettings });
+        }
 
-      const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
-      await setupIntent.update({
-        status: 'succeeded',
-        last_setup_error: null,
-        setup_details: { arcblock: paymentDetails },
-        ...paymentSettings,
-      });
-      await subscription.update({
-        status: subscription.trial_end ? 'trialing' : 'active',
-        payment_details: { arcblock: paymentDetails },
-      });
+        const paymentDetails = await executeOcapTransactions(userDid, userPk, claims, paymentMethod);
+        await setupIntent.update({
+          status: 'succeeded',
+          last_setup_error: null,
+          setup_details: { arcblock: paymentDetails },
+          ...paymentSettings,
+        });
+        await subscription.update({
+          status: subscription.trial_end ? 'trialing' : 'active',
+          payment_details: { arcblock: paymentDetails },
+        });
 
-      await checkoutSession.update({ status: 'complete', payment_status: 'paid' });
-      if (invoice) {
-        invoiceQueue.pushAndWait({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
-      }
-      await addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
-      logger.info('CheckoutSession updated on setup done', {
-        checkoutSession: checkoutSession.id,
-        setupIntent: setupIntent.id,
-        paymentDetails,
-      });
+        await checkoutSession.update({ status: 'complete', payment_status: 'paid' });
+        if (invoice) {
+          invoiceQueue.pushAndWait({ id: invoice.id, job: { invoiceId: invoice.id, retryOnError: false } });
+        }
+        await addSubscriptionJob(subscription, 'cycle', false, subscription.trial_end);
+        logger.info('CheckoutSession updated on setup done', {
+          checkoutSession: checkoutSession.id,
+          setupIntent: setupIntent.id,
+          paymentDetails,
+        });
 
-      return { hash: paymentDetails.tx_hash };
+        return { hash: paymentDetails.tx_hash };
+      } catch (err) {
+        logger.error('Failed to finalize setup', { setupIntent: setupIntent.id, error: err });
+        await setupIntent.update({ status: 'requires_capture' });
+        return {};
+      }
     }
 
     throw new Error(`Payment method ${paymentMethod.type} not supported`);

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

@@ -454,7 +454,9 @@ export async function ensureInvoiceAndItems({
 
     return {
       price,
-      amount: new BN(getPriceUintAmountByCurrency(price, props.currency_id)).mul(new BN(x.quantity)).toString(),
+      amount:
+        x.custom_amount ||
+        new BN(getPriceUintAmountByCurrency(price, props.currency_id)).mul(new BN(x.quantity)).toString(),
       // @ts-ignore
       description: price.product.name,
       period: undefined,

package/api/src/routes/donations.ts

@@ -0,0 +1,157 @@
+import { Joi } from '@arcblock/validator';
+import { Router } from 'express';
+
+import { createListParamSchema } from '../libs/api';
+import logger from '../libs/logger';
+import { CheckoutSession } from '../store/models/checkout-session';
+import { Customer } from '../store/models/customer';
+import { PaymentLink } from '../store/models/payment-link';
+import { PaymentMethod } from '../store/models/payment-method';
+import { Price } from '../store/models/price';
+import type { DonationSettings } from '../store/models/types';
+import { createPaymentLink } from './payment-links';
+import { createProductAndPrices } from './products';
+
+const router = Router();
+
+// FIXME: add more custom validation here for amount
+const donationSchema = Joi.object<DonationSettings>({
+  target: Joi.string().max(128).required(),
+  title: Joi.string().required(),
+  description: Joi.string().required(),
+  reference: Joi.string().required(),
+  beneficiaries: Joi.array()
+    .items(
+      Joi.object({
+        address: Joi.DID().required(),
+        share: Joi.number().positive().required(),
+        memo: Joi.string().max(64).optional(),
+      })
+    )
+    .max(8)
+    .optional()
+    .default([]),
+  amount: Joi.object({
+    presets: Joi.array().items(Joi.number().positive()).optional().default([]),
+    preset: Joi.number().positive().optional(),
+    minimum: Joi.number().positive().optional(),
+    maximum: Joi.number().positive().optional(),
+    custom: Joi.boolean().optional().default(true),
+  }),
+  message: Joi.object({
+    success: Joi.string().optional(),
+    summary: Joi.string().optional(),
+  }),
+});
+// prepare donation payment links
+router.post('/', async (req, res) => {
+  try {
+    const payload = await donationSchema.validateAsync(req.body, { stripUnknown: true, convert: true });
+    const link = await PaymentLink.findOne({ where: { 'donation_settings.target': payload.target } });
+    if (link) {
+      await link.update({
+        name: payload.title,
+        submit_type: 'donate',
+        donation_settings: payload,
+        after_completion: {
+          type: 'hosted_confirmation',
+          hosted_confirmation: {
+            custom_message: payload.message?.success || '',
+          },
+        },
+      });
+      res.json(link.toJSON());
+      return;
+    }
+
+    let price = await Price.findByPkOrLookupKey(payload.target);
+    if (!price) {
+      const result = await createProductAndPrices({
+        type: 'service',
+        livemode: req.livemode,
+        name: payload.title,
+        description: payload.description,
+        currency_id: req.currency.id,
+        prices: [
+          {
+            type: 'one_time',
+            unit_amount: '0',
+            billing_schema: 'per_unit',
+            lookup_key: payload.target,
+            custom_unit_amount: {
+              presets: payload.amount.presets || [],
+              preset: payload.amount.preset || null,
+              maximum: payload.amount.maximum || null,
+              minimum: payload.amount.minimum || '0',
+            },
+          },
+        ],
+        metadata: {},
+      });
+
+      price = result.prices[0] as Price;
+    }
+
+    const result = await createPaymentLink({
+      livemode: !!req.livemode,
+      created_via: req.user?.via,
+      currency_id: req.currency.id,
+      name: payload.title,
+      submit_type: 'donate',
+      line_items: [{ price_id: price.id, quantity: 1 }],
+      donation_settings: payload,
+      after_completion: {
+        type: 'hosted_confirmation',
+        hosted_confirmation: {
+          custom_message: payload.message?.success || '',
+        },
+      },
+    });
+    res.json(result);
+  } catch (err) {
+    logger.error('prepare payment link for donation', err);
+    res.status(400).json({ error: err.message });
+  }
+});
+
+// get donations by target
+const paginationSchema = createListParamSchema<{ target: string }>({ target: Joi.string().required() }, 20);
+router.get('/', async (req, res) => {
+  try {
+    const { page, pageSize, target } = await paginationSchema.validateAsync(req.query, {
+      convert: true,
+      stripUnknown: true,
+    });
+    const { rows, count } = await CheckoutSession.findAndCountAll({
+      where: { payment_link_id: target, status: 'complete' },
+      attributes: [
+        'id',
+        'customer_id',
+        'customer_did',
+        'amount_total',
+        'payment_intent_id',
+        'payment_details',
+        'created_at',
+        'updated_at',
+      ],
+      order: [['created_at', 'DESC']],
+      offset: (page - 1) * pageSize,
+      include: [{ model: Customer, as: 'customer', attributes: ['id', 'did', 'name'] }],
+      limit: pageSize,
+    });
+
+    const method = await PaymentMethod.findByPk(req.currency.payment_method_id);
+
+    res.json({
+      supporters: rows,
+      currency: req.currency,
+      method,
+      total: count,
+      paging: { page, pageSize },
+    });
+  } catch (err) {
+    res.status(400).json({ error: err.message, supporters: [] });
+  }
+});
+
+export default router;

package/api/src/routes/index.ts

@@ -3,6 +3,7 @@ import { Router } from 'express';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import checkoutSessions from './checkout-sessions';
 import customers from './customers';
+import donations from './donations';
 import events from './events';
 import stripe from './integrations/stripe';
 import invoices from './invoices';
@@ -11,6 +12,7 @@ import paymentCurrencies from './payment-currencies';
 import paymentIntents from './payment-intents';
 import paymentLinks from './payment-links';
 import paymentMethods from './payment-methods';
+import payouts from './payouts';
 import prices from './prices';
 import pricingTables from './pricing-table';
 import products from './products';
@@ -46,6 +48,7 @@ router.use(async (req, _, next) => {
 
 router.use('/checkout-sessions', checkoutSessions);
 router.use('/customers', customers);
+router.use('/donations', donations);
 router.use('/events', events);
 router.use('/invoices', invoices);
 router.use('/integrations/stripe', stripe);
@@ -57,6 +60,7 @@ router.use('/payment-currencies', paymentCurrencies);
 router.use('/prices', prices);
 router.use('/pricing-tables', pricingTables);
 router.use('/products', products);
+router.use('/payouts', payouts);
 router.use('/redirect', redirect);
 router.use('/refunds', refunds);
 router.use('/settings', settings);

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

@@ -17,8 +17,8 @@ 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 authAdmin = authenticate<PaymentIntent>({ component: true, roles: ['owner', 'admin'] });
+const authMine = authenticate<PaymentIntent>({ component: true, roles: ['owner', 'admin'], mine: true });
 const authPortal = authenticate<PaymentIntent>({
   component: true,
   roles: ['owner', 'admin'],

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

@@ -1,5 +1,5 @@
+import { Joi } from '@arcblock/validator';
 import { Router } from 'express';
-import Joi from 'joi';
 import pick from 'lodash/pick';
 import type { WhereOptions } from 'sequelize';
 
@@ -31,7 +31,7 @@ const formatBeforeSave = (payload: any) => {
         terms_of_service: 'none',
       },
       invoice_creation: {
-        enabled: false,
+        enabled: true,
       },
       phone_number_collection: {
         enabled: false,
@@ -47,6 +47,7 @@ const formatBeforeSave = (payload: any) => {
       },
       submit_type: 'pay',
       cross_sell_behavior: 'auto',
+      donation_settings: null,
     },
     pick(payload, [
       'name',
@@ -64,6 +65,7 @@ const formatBeforeSave = (payload: any) => {
       'subscription_data',
       'nft_mint_settings',
       'cross_sell_behavior',
+      'donation_settings',
       'metadata',
     ])
   );
@@ -110,6 +112,10 @@ export async function createPaymentLink(payload: any) {
   }
 
   const items = await Price.expand(raw.line_items);
+  if (items.find((x) => x.price.custom_unit_amount) && items.length > 1) {
+    throw new Error('Multiple items with custom unit amount are not supported in payment link');
+  }
+
   for (let i = 0; i < items.length; i++) {
     const result = isLineItemAligned(items, i);
     if (result.currency === false) {
@@ -128,7 +134,6 @@ export async function createPaymentLink(payload: any) {
 }
 
 // FIXME: @wangshijun use schema validation
-// eslint-disable-next-line consistent-return
 router.post('/', auth, async (req, res) => {
   try {
     const result = await createPaymentLink({

package/api/src/routes/payouts.ts

@@ -0,0 +1,151 @@
+import { isValid } from '@arcblock/did';
+import { Router } from 'express';
+import Joi from 'joi';
+import pick from 'lodash/pick';
+
+import { createListParamSchema, getWhereFromKvQuery } from '../libs/api';
+import { authenticate } from '../libs/security';
+import { formatMetadata } from '../libs/util';
+import { Customer } from '../store/models/customer';
+import { PaymentCurrency } from '../store/models/payment-currency';
+import { PaymentIntent } from '../store/models/payment-intent';
+import { PaymentMethod } from '../store/models/payment-method';
+import { Payout } from '../store/models/payout';
+
+const router = Router();
+const authAdmin = authenticate<Payout>({ component: true, roles: ['owner', 'admin'] });
+const authMine = authenticate<Payout>({ component: true, roles: ['owner', 'admin'], mine: true });
+const authPortal = authenticate<Payout>({
+  component: true,
+  roles: ['owner', 'admin'],
+  record: {
+    // @ts-ignore
+    model: Payout,
+    field: 'customer_id',
+  },
+});
+
+// list payment intents
+const paginationSchema = createListParamSchema<{
+  status?: string;
+  payment_intent_id?: string;
+  customer_id?: string;
+  customer_did?: string;
+  currency_id?: string;
+}>({
+  status: Joi.string().empty(''),
+  payment_intent_id: Joi.string().empty(''),
+  customer_id: Joi.string().empty(''),
+  customer_did: Joi.string().empty(''),
+  currency_id: Joi.string().empty(''),
+});
+router.get('/', authMine, async (req, res) => {
+  const { page, pageSize, status, livemode, ...query } = await paginationSchema.validateAsync(req.query, {
+    stripUnknown: false,
+    allowUnknown: true,
+  });
+  const where = getWhereFromKvQuery(query.q);
+
+  if (status) {
+    where.status = status
+      .split(',')
+      .map((x) => x.trim())
+      .filter(Boolean);
+  }
+  if (query.customer_id) {
+    where.customer_id = query.customer_id;
+  }
+  if (query.customer_did && isValid(query.customer_did)) {
+    const customer = await Customer.findOne({ where: { did: query.customer_did } });
+    if (customer) {
+      where.customer_id = customer.id;
+    } else {
+      res.json({ count: 0, list: [] });
+      return;
+    }
+  }
+  if (query.payment_intent_id) {
+    where.payment_intent_id = query.payment_intent_id;
+  }
+
+  if (query.currency_id) {
+    where.currency_id = query.currency_id;
+  }
+
+  if (typeof livemode === 'boolean') {
+    where.livemode = livemode;
+  }
+
+  Object.keys(query)
+    .filter((x) => x.startsWith('metadata.'))
+    .forEach((key: string) => {
+      // @ts-ignore
+      where[key] = query[key];
+    });
+
+  try {
+    const { rows: list, count } = await Payout.findAndCountAll({
+      where,
+      order: [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']],
+      offset: (page - 1) * pageSize,
+      limit: pageSize,
+      include: [
+        { model: PaymentCurrency, as: 'paymentCurrency' },
+        { model: PaymentMethod, as: 'paymentMethod' },
+        { model: PaymentIntent, as: 'paymentIntent' },
+        { model: Customer, as: 'customer' },
+      ],
+    });
+
+    res.json({ count, list, paging: { page, pageSize } });
+  } catch (err) {
+    console.error(err);
+    res.json({ count: 0, list: [], paging: { page, pageSize } });
+  }
+});
+
+router.get('/:id', authPortal, async (req, res) => {
+  try {
+    const doc = await Payout.findOne({
+      where: { id: req.params.id },
+      include: [
+        { model: PaymentCurrency, as: 'paymentCurrency' },
+        { model: PaymentMethod, as: 'paymentMethod' },
+        { model: PaymentIntent, as: 'paymentIntent' },
+        { model: Customer, as: 'customer' },
+      ],
+    });
+
+    if (doc) {
+      res.json({ ...doc.toJSON() });
+    } else {
+      res.status(404).json(null);
+    }
+  } catch (err) {
+    console.error(err);
+    res.status(500).json({ error: `Failed to get payout: ${err.message}` });
+  }
+});
+
+// eslint-disable-next-line consistent-return
+router.put('/:id', authAdmin, async (req, res) => {
+  try {
+    const doc = await Payout.findByPk(req.params.id as string);
+    if (!doc) {
+      return res.status(404).json({ error: 'Payout 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/products.ts

@@ -10,6 +10,7 @@ import { formatMetadata } from '../libs/util';
 import { PaymentCurrency } from '../store/models/payment-currency';
 import { Price } from '../store/models/price';
 import { Product } from '../store/models/product';
+import type { CustomUnitAmount } from '../store/models/types';
 
 const router = Router();
 
@@ -36,8 +37,8 @@ export async function createProductAndPrices(payload: any) {
 
   const product = await Product.create(raw as Product);
   if (Array.isArray(payload.prices) && payload.prices.length) {
-    if (payload.prices.some((x: any) => !x.unit_amount)) {
-      throw new Error('unit_amount is required for price');
+    if (payload.prices.some((x: any) => !x.unit_amount && !x.custom_unit_amount)) {
+      throw new Error('unit_amount or custom_unit_amount is required for price');
     }
 
     const currencies = await PaymentCurrency.findAll({ where: { active: true } });
@@ -51,10 +52,27 @@ export async function createProductAndPrices(payload: any) {
       if (!currency) {
         throw new Error(`currency ${price.currency_id} used in price not found or inactive`);
       }
-      if (!price.unit_amount) {
-        throw new Error('price.unit_amount is required');
+      if (price.custom_unit_amount) {
+        // @ts-ignore
+        ['preset', 'maximum', 'minimum'].forEach((key: keyof CustomUnitAmount) => {
+          if (price.custom_unit_amount?.[key]) {
+            price.custom_unit_amount[key] = fromTokenToUnit(
+              price.custom_unit_amount[key] as string,
+              currency.decimal
+            ).toString();
+          }
+        });
+        if (Array.isArray(price.custom_unit_amount.presets)) {
+          price.custom_unit_amount.presets = price.custom_unit_amount.presets.map((x) =>
+            fromTokenToUnit(x, currency.decimal).toString()
+          );
+        }
+      } else {
+        if (!price.unit_amount) {
+          throw new Error('price.unit_amount is required');
+        }
+        price.unit_amount = fromTokenToUnit(price.unit_amount, currency.decimal).toString();
       }
-      price.unit_amount = fromTokenToUnit(price.unit_amount, currency.decimal).toString();
 
       if (Array.isArray(price.currency_options)) {
         price.currency_options = Price.formatCurrencies(price.currency_options, currencies);
@@ -66,7 +84,7 @@ export async function createProductAndPrices(payload: any) {
           currency_id: price.currency_id,
           unit_amount: price.unit_amount,
           tiers: null,
-          custom_unit_amount: null,
+          custom_unit_amount: price.custom_unit_amount,
         });
       }
 

package/api/src/routes/usage-records.ts

@@ -78,9 +78,12 @@ router.post('/', auth, async (req, res) => {
 // @link https://stripe.com/docs/api/usage_records/subscription_item_summary_list
 const schema = createListParamSchema<{
   subscription_item_id: string;
-}>({
-  subscription_item_id: Joi.string().required(),
-});
+}>(
+  {
+    subscription_item_id: Joi.string().required(),
+  },
+  100
+);
 router.get('/summary', auth, async (req, res) => {
   const { page, pageSize, ...query } = await schema.validateAsync(req.query, { stripUnknown: true });
 

package/api/src/store/migrations/20240408-payout.ts

@@ -0,0 +1,36 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+import models from '../models';
+
+export const up: Migration = async ({ context }) => {
+  await context.createTable('payouts', models.Payout.GENESIS_ATTRIBUTES);
+  await safeApplyColumnChanges(context, {
+    payment_links: [
+      {
+        name: 'donation_settings',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+          defaultValue: {},
+        },
+      },
+    ],
+    payment_intents: [
+      {
+        name: 'beneficiaries',
+        field: {
+          type: DataTypes.JSON,
+          allowNull: true,
+          defaultValue: [],
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.dropTable('payouts');
+  await context.removeColumn('payment_links', 'donation_settings');
+  await context.removeColumn('payment_intents', 'beneficiaries');
+};

package/api/src/store/models/checkout-session.ts

@@ -463,6 +463,11 @@ export class CheckoutSession extends Model<InferAttributes<CheckoutSession>, Inf
       foreignKey: 'id',
       as: 'currency',
     });
+    this.hasOne(models.Customer, {
+      sourceKey: 'customer_id',
+      foreignKey: 'id',
+      as: 'customer',
+    });
   }
 
   public static findByPkOrClientRefId(id: string, options: FindOptions<CheckoutSession> = {}) {

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

@@ -15,10 +15,11 @@ import {
 import { createEvent } from '../../libs/audit';
 import CustomError from '../../libs/error';
 import { getLock } from '../../libs/lock';
-import { createIdGenerator } from '../../libs/util';
+import { createCodeGenerator, createIdGenerator } from '../../libs/util';
 import type { CustomerAddress, CustomerShipping } from './types';
 
 export const nextCustomerId = createIdGenerator('cus', 14);
+export const nextInvoicePrefix = createCodeGenerator('', 8);
 
 // eslint-disable-next-line prettier/prettier
 export class Customer extends Model<InferAttributes<Customer>, InferCreationAttributes<Customer>> {
@@ -271,6 +272,10 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
       ...options,
     });
   }
+
+  public static getInvoicePrefix() {
+    return nextInvoicePrefix();
+  }
 }
 
 export type TCustomer = InferAttributes<Customer>;