payment-kit 1.16.16 → 1.16.18

package/api/src/routes/customers.ts

@@ -96,7 +96,7 @@ router.get('/me', sessionMiddleware(), async (req, res) => {
       }
     } else {
       const [summary, stake, token] = await Promise.all([
-        doc.getSummary(),
+        doc.getSummary(livemode),
         getStakeSummaryByDid(doc.did, livemode),
         getTokenSummaryByDid(doc.did, livemode),
       ]);
@@ -131,7 +131,7 @@ router.get('/:id/summary', auth, async (req, res) => {
     }
 
     const [summary, stake, token] = await Promise.all([
-      doc.getSummary(),
+      doc.getSummary(doc.livemode),
       getStakeSummaryByDid(doc.did, doc.livemode),
       getTokenSummaryByDid(doc.did, doc.livemode),
     ]);

package/api/src/routes/invoices.ts

@@ -216,13 +216,18 @@ router.get('/:id', authPortal, async (req, res) => {
       const prices = (await Price.findAll()).map((x) => x.toJSON());
       // @ts-ignore
       expandLineItems(json.lines, products, prices);
-      res.json(json);
-    } else {
-      res.status(404).json(null);
+      if (doc.metadata?.invoice_id) {
+        const relatedInvoice = await Invoice.findByPk(doc.metadata.invoice_id, {
+          attributes: ['id', 'number', 'status', 'billing_reason'],
+        });
+        return res.json({ ...json, relatedInvoice });
+      }
+      return res.json(json);
     }
+    return res.status(404).json(null);
   } catch (err) {
     console.error(err);
-    res.status(500).json({ error: `Failed to get invoice: ${err.message}` });
+    return res.status(500).json({ error: `Failed to get invoice: ${err.message}` });
   }
 });
 

package/api/src/routes/subscriptions.ts

@@ -24,16 +24,25 @@ import { expandLineItems, getFastCheckoutAmount, isLineItemAligned } from '../li
 import {
   createProration,
   finalizeSubscriptionUpdate,
+  getPastInvoicesAmount,
   getSubscriptionCreateSetup,
   getSubscriptionPaymentAddress,
   getSubscriptionRefundSetup,
   getSubscriptionStakeReturnSetup,
   getSubscriptionStakeSlashSetup,
+  getSubscriptionUnpaidInvoicesCount,
   getUpcomingInvoiceAmount,
+  isSubscriptionOverdraftProtectionEnabled,
 } from '../libs/subscription';
 import { MAX_SUBSCRIPTION_ITEM_COUNT, formatMetadata } from '../libs/util';
 import { invoiceQueue } from '../queues/invoice';
-import { addSubscriptionJob, slashStakeQueue, subscriptionQueue } from '../queues/subscription';
+import {
+  addSubscriptionJob,
+  returnOverdraftProtectionQueue,
+  slashOverdraftProtectionQueue,
+  slashStakeQueue,
+  subscriptionQueue,
+} from '../queues/subscription';
 import type { TLineItemExpanded } from '../store/models';
 import { Customer } from '../store/models/customer';
 import { Invoice } from '../store/models/invoice';
@@ -50,10 +59,11 @@ import { Subscription, TSubscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
 import type { LineItem, ServiceAction, SubscriptionUpdateItem } from '../store/models/types';
 import { UsageRecord } from '../store/models/usage-record';
-import { cleanupInvoiceAndItems, ensureInvoiceAndItems } from './connect/shared';
+import { cleanupInvoiceAndItems, ensureInvoiceAndItems } from '../libs/invoice';
 import { createUsageRecordQueryFn } from './usage-records';
 import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
 import { getTokenByAddress } from '../integrations/arcblock/stake';
+import { ensureOverdraftProtectionPrice } from '../libs/overdraft-protection';
 
 const router = Router();
 const auth = authenticate<Subscription>({ component: true, roles: ['owner', 'admin'] });
@@ -1735,6 +1745,41 @@ router.get('/:id/upcoming', authPortal, async (req, res) => {
   }
 });
 
+router.get('/:id/cycle-amount', authPortal, async (req, res) => {
+  const subscription = await Subscription.findByPk(req.params.id);
+  if (!subscription) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+  const currency = await PaymentCurrency.findByPk(subscription.currency_id);
+  if (!currency) {
+    return res.status(404).json({ error: 'Currency not found' });
+  }
+  // get upcoming invoice
+  const result = await getUpcomingInvoiceAmount(subscription.id);
+  // get past invoices
+  const pastMaxAmount = await getPastInvoicesAmount(subscription.id, 'max');
+
+  // return max amount
+  const nextAmount = new BN(result.amount === '0' ? result.minExpectedAmount : result.amount);
+
+  const maxAmount = new BN(pastMaxAmount.amount).lte(new BN(nextAmount)) ? nextAmount : pastMaxAmount.amount;
+
+  if (req.query?.overdraftProtection) {
+    const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
+    const invoicePrice = price.currency_options.find((x: any) => x.currency_id === subscription?.currency_id);
+    const gas = invoicePrice?.unit_amount;
+    return res.json({
+      amount: new BN(maxAmount).add(new BN(gas)).toString(),
+      gas,
+      currency,
+    });
+  }
+  return res.json({
+    amount: maxAmount,
+    currency,
+  });
+});
+
 // slash stake
 router.put('/:id/slash-stake', auth, async (req, res) => {
   const { error: slashReasonError } = SlashStakeSchema.validate(req.body?.slashReason);
@@ -1959,4 +2004,129 @@ router.get('/:id/delegation', authPortal, async (req, res) => {
     return res.json(null);
   }
 });
+
+router.get('/:id/overdraft-protection', authPortal, async (req, res) => {
+  const subscription = await Subscription.findByPk(req.params.id);
+  if (!subscription) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+  try {
+    const { enabled, remaining, unused, used, shouldPay } =
+      await isSubscriptionOverdraftProtectionEnabled(subscription);
+    const upcoming = await getUpcomingInvoiceAmount(req.params.id as string);
+    const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
+    const invoicePrice = price.currency_options.find((x: any) => x.currency_id === subscription?.currency_id);
+    const gas = invoicePrice?.unit_amount;
+    return res.json({
+      enabled,
+      remaining,
+      unused,
+      used,
+      upcoming,
+      gas,
+      shouldPay,
+    });
+  } catch (err) {
+    console.error(err);
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+const overdraftProtectionSchema = createListParamSchema<{
+  amount: string;
+  enabled: boolean;
+  return_stake: boolean;
+}>({
+  amount: Joi.number().empty(0).optional(),
+  enabled: Joi.boolean().required(),
+  return_stake: Joi.boolean().empty(false).optional(),
+});
+// 订阅保护
+router.post('/:id/overdraft-protection', authPortal, async (req, res) => {
+  try {
+    const {
+      error: overdraftProtectionError,
+      value: { amount, return_stake: returnStake, enabled },
+    } = overdraftProtectionSchema.validate(req.body);
+    if (overdraftProtectionError) {
+      return res.status(400).json({ error: `Overdraft protection invalid: ${overdraftProtectionError.message}` });
+    }
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+    const customer = await Customer.findByPkOrDid(req.user?.did as string);
+    if (!customer) {
+      return res.status(404).json({ error: 'Customer not found' });
+    }
+    const { remaining, used } = await isSubscriptionOverdraftProtectionEnabled(subscription);
+    if (returnStake && remaining !== '0' && !enabled) {
+      // disable overdraft protection
+      await subscription.update({
+        // @ts-ignore
+        overdraft_protection: {
+          ...(subscription.overdraft_protection || {}),
+          enabled: false,
+        },
+      });
+      returnOverdraftProtectionQueue.push({
+        id: `return-overdraft-protection-${subscription.id}`,
+        job: { subscriptionId: subscription.id },
+      });
+      logger.info('Return overdraft protection stake scheduled', {
+        subscriptionId: subscription.id,
+        requestedBy: req.user?.did,
+      });
+      return res.json({
+        open: false,
+        overdraft_protection: subscription.overdraft_protection,
+      });
+    }
+    if (remaining !== '0' && used !== '0' && !enabled) {
+      // slash stake
+      slashOverdraftProtectionQueue.push({
+        id: `slash-overdraft-protection-${subscription.id}`,
+        job: { subscriptionId: subscription.id },
+      });
+      logger.info('Slash overdraft protection stake scheduled', {
+        subscriptionId: subscription.id,
+        requestedBy: req.user?.did,
+      });
+    }
+    await subscription.update({
+      // @ts-ignore
+      overdraft_protection: {
+        ...subscription.overdraft_protection,
+        enabled,
+      },
+    });
+    if (enabled && Number(amount) > 0) {
+      return res.json({
+        open: true,
+        amount,
+        overdraft_protection: subscription.overdraft_protection,
+      });
+    }
+    if (enabled) {
+      // release the exhausted lock, so that the notification can be sent again if overdraft protection exhausted
+      await Lock.release(`${subscription.id}-${subscription.currency_id}-overdraft-protection-exhausted`);
+    }
+    return res.json({
+      open: false,
+      overdraft_protection: subscription.overdraft_protection,
+    });
+  } catch (err) {
+    console.error(err);
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+router.get('/:id/unpaid-invoices', authPortal, async (req, res) => {
+  const subscription = await Subscription.findByPk(req.params.id);
+  if (!subscription) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+  const count = await getSubscriptionUnpaidInvoicesCount(subscription);
+  return res.json({ count });
+});
 export default router;

package/api/src/store/migrate.ts

@@ -9,16 +9,15 @@ import { sequelize } from './sequelize';
 const umzug = new Umzug({
   migrations: {
     glob: ['**/migrations/*.{ts,js}', { cwd: __dirname }],
-    // @FIXME: @wangshijun  jianchao这边的注释了才能 blocklet dev 成功
-    // resolve: ({ name, path, context }) => {
-    //   // eslint-disable-next-line import/no-dynamic-require, global-require
-    //   const migration = require(path!);
-    //   return {
-    //     name: name.replace(/\.ts$/, '.js'),
-    //     up: () => migration.up({ context }),
-    //     down: () => migration.down({ context }),
-    //   };
-    // },
+    resolve: ({ name, path, context }) => {
+      // eslint-disable-next-line import/no-dynamic-require, global-require
+      const migration = require(path!);
+      return {
+        name: name.replace(/\.ts$/, '.js'),
+        up: () => migration.up({ context }),
+        down: () => migration.down({ context }),
+      };
+    },
   },
   context: sequelize.getQueryInterface(),
   storage: new SequelizeStorage({ sequelize }),

package/api/src/store/migrations/20240905-index.ts

@@ -1,76 +1,111 @@
+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,
+  columns: string[],
+  indexName: string
+) => {
+  if (await indexExists(table, indexName, queryInterface)) {
+    /* eslint-disable no-console */
+    console.log(`Index ${indexName} already exists on ${table}, skipping...`);
+    return;
+  }
+  await queryInterface.addIndex(table, columns, { name: indexName });
+};
+
 export const up: Migration = async ({ context: queryInterface }) => {
   try {
-    await queryInterface.addIndex('subscriptions', ['current_period_start', 'current_period_end'], {
-      name: 'idx_subscription_period',
-    });
-    await queryInterface.addIndex('subscriptions', ['status'], {
-      name: 'idx_subscription_status',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'subscriptions',
+      ['current_period_start', 'current_period_end'],
+      'idx_subscription_period'
+    );
+    await createIndexIfNotExists(queryInterface, 'subscriptions', ['status'], 'idx_subscription_status');
 
-    await queryInterface.addIndex('subscription_items', ['subscription_id', 'price_id'], {
-      name: 'idx_subscription_item_subscription_id_price_id',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'subscription_items',
+      ['subscription_id', 'price_id'],
+      'idx_subscription_item_subscription_id_price_id'
+    );
 
-    await queryInterface.addIndex('invoices', ['status', 'collection_method'], {
-      name: 'idx_invoice_status_collection',
-    });
-    await queryInterface.addIndex('invoices', ['subscription_id'], {
-      name: 'idx_invoice_subscription_id',
-    });
-    await queryInterface.addIndex('invoices', ['currency_id'], {
-      name: 'idx_invoice_currency_id',
-    });
-    await queryInterface.addIndex('invoices', ['customer_id'], {
-      name: 'idx_invoice_customer_id',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'invoices',
+      ['status', 'collection_method'],
+      'idx_invoice_status_collection'
+    );
+    await createIndexIfNotExists(queryInterface, 'invoices', ['subscription_id'], 'idx_invoice_subscription_id');
+    await createIndexIfNotExists(queryInterface, 'invoices', ['currency_id'], 'idx_invoice_currency_id');
+    await createIndexIfNotExists(queryInterface, 'invoices', ['customer_id'], 'idx_invoice_customer_id');
 
-    await queryInterface.addIndex('payment_intents', ['invoice_id'], {
-      name: 'idx_payment_intent_invoice_id',
-    });
-    await queryInterface.addIndex('payment_intents', ['customer_id'], {
-      name: 'idx_payment_intent_customer_id',
-    });
-    await queryInterface.addIndex('payment_intents', ['currency_id'], {
-      name: 'idx_payment_intent_currency_id',
-    });
-    await queryInterface.addIndex('payment_intents', ['status', 'updated_at'], {
-      name: 'idx_payment_intent_status_updated_at',
-    });
+    await createIndexIfNotExists(queryInterface, 'payment_intents', ['invoice_id'], 'idx_payment_intent_invoice_id');
+    await createIndexIfNotExists(queryInterface, 'payment_intents', ['customer_id'], 'idx_payment_intent_customer_id');
+    await createIndexIfNotExists(queryInterface, 'payment_intents', ['currency_id'], 'idx_payment_intent_currency_id');
+    await createIndexIfNotExists(
+      queryInterface,
+      'payment_intents',
+      ['status', 'updated_at'],
+      'idx_payment_intent_status_updated_at'
+    );
 
-    await queryInterface.addIndex('webhook_attempts', ['webhook_endpoint_id'], {
-      name: 'idx_webhook_attempts_webhook_endpoint_id',
-    });
-    await queryInterface.addIndex('webhook_attempts', ['event_id'], {
-      name: 'idx_webhook_attempts_event_id',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'webhook_attempts',
+      ['webhook_endpoint_id'],
+      'idx_webhook_attempts_webhook_endpoint_id'
+    );
+    await createIndexIfNotExists(queryInterface, 'webhook_attempts', ['event_id'], 'idx_webhook_attempts_event_id');
 
-    await queryInterface.addIndex('usage_records', ['subscription_item_id', 'timestamp'], {
-      name: 'idx_usage_records_subscription_item_id_timestamp',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'usage_records',
+      ['subscription_item_id', 'timestamp'],
+      'idx_usage_records_subscription_item_id_timestamp'
+    );
 
-    await queryInterface.addIndex('webhook_endpoints', ['status', 'livemode'], {
-      name: 'idx_webhook_endpoint_status_livemode',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'webhook_endpoints',
+      ['status', 'livemode'],
+      'idx_webhook_endpoint_status_livemode'
+    );
 
-    await queryInterface.addIndex('payment_stats', ['timestamp', 'currency_id'], {
-      name: 'idx_payment_stats_timestamp_currency_id',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'payment_stats',
+      ['timestamp', 'currency_id'],
+      'idx_payment_stats_timestamp_currency_id'
+    );
 
-    await queryInterface.addIndex('payouts', ['updated_at', 'status'], {
-      name: 'idx_payouts_updated_at_status',
-    });
+    await createIndexIfNotExists(queryInterface, 'payouts', ['updated_at', 'status'], 'idx_payouts_updated_at_status');
 
-    await queryInterface.addIndex('refunds', ['status', 'type', 'updated_at'], {
-      name: 'idx_refunds_status_type_updated_at',
-    });
-    await queryInterface.addIndex('refunds', ['subscription_id', 'type'], {
-      name: 'idx_refunds_subscription_id_type',
-    });
-    await queryInterface.addIndex('refunds', ['payment_intent_id', 'type'], {
-      name: 'idx_refunds_payment_intent_id_type',
-    });
+    await createIndexIfNotExists(
+      queryInterface,
+      'refunds',
+      ['status', 'type', 'updated_at'],
+      'idx_refunds_status_type_updated_at'
+    );
+    await createIndexIfNotExists(
+      queryInterface,
+      'refunds',
+      ['subscription_id', 'type'],
+      'idx_refunds_subscription_id_type'
+    );
+    await createIndexIfNotExists(
+      queryInterface,
+      'refunds',
+      ['payment_intent_id', 'type'],
+      'idx_refunds_payment_intent_id_type'
+    );
   } catch (error) {
     console.error('Failed to create indexes', error);
     throw error;

package/api/src/store/migrations/20241203-overdraft-protection.ts

@@ -0,0 +1,25 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  await safeApplyColumnChanges(context, {
+    customers: [
+      {
+        name: 'overdraft_protection',
+        field: {
+          type: DataTypes.JSON,
+          defaultValue: JSON.stringify({
+            status: 'inactive',
+            remaining_quantity: 0,
+            total: 0,
+          }),
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('customers', 'overdraft_protection');
+};

package/api/src/store/migrations/20241216-update-overdraft-protection.ts

@@ -0,0 +1,30 @@
+import { DataTypes } from 'sequelize';
+
+import { Migration, safeApplyColumnChanges } from '../migrate';
+
+export const up: Migration = async ({ context }) => {
+  // 如果customer存在overdraft_protection，则删除
+  const columns = await context.describeTable('customers');
+  if (columns.overdraft_protection) {
+    await context.removeColumn('customers', 'overdraft_protection');
+  }
+  await safeApplyColumnChanges(context, {
+    subscriptions: [
+      {
+        name: 'overdraft_protection',
+        field: {
+          type: DataTypes.JSON,
+          defaultValue: JSON.stringify({
+            enabled: false,
+            payment_method_id: null,
+            payment_details: null,
+          }),
+        },
+      },
+    ],
+  });
+};
+
+export const down: Migration = async ({ context }) => {
+  await context.removeColumn('subscriptions', 'overdraft_protection');
+};

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

@@ -162,13 +162,13 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
     return `${this.invoice_prefix}-${padStart(sequence.toString(), 4, '0')}`;
   }
 
-  public async getSummary() {
+  public async getSummary(livemode?: boolean) {
     const { PaymentIntent, Refund, Invoice } = this.sequelize.models;
     const [paid, [due], refunded] = await Promise.all([
       // @ts-ignore
       PaymentIntent!.getPaidAmountByCustomer(this.id),
       // @ts-ignore
-      Invoice!.getUncollectibleAmount({ customerId: this.id }),
+      Invoice!.getUncollectibleAmount({ customerId: this.id, livemode }),
       // @ts-ignore
       Refund!.getRefundAmountByCustomer(this.id),
     ]);

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

@@ -61,6 +61,8 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
     | 'upcoming'
     | 'slash_stake'
     | 'stake'
+    | 'overdraft_protection'
+    | 'stake_overdraft_protection'
     | 'recharge',
     string
   >;
@@ -554,11 +556,13 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
     subscriptionId,
     currencyId,
     excludedInvoiceId,
+    livemode,
   }: {
     customerId?: string;
     subscriptionId?: string;
     currencyId?: string;
     excludedInvoiceId?: string;
+    livemode?: boolean;
   }) {
     if (!customerId && !subscriptionId) {
       throw new Error('customerId or subscriptionId is required for getUncollectibleAmount');
@@ -579,6 +583,9 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
     if (excludedInvoiceId) {
       where.id = { [Op.not]: excludedInvoiceId };
     }
+    if (typeof livemode === 'boolean') {
+      where.livemode = livemode;
+    }
 
     return this._getUncollectibleAmount(where);
   }

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

@@ -76,6 +76,13 @@ export class Lock extends Model<InferAttributes<Lock>, InferCreationAttributes<L
     return !!exist && exist.release_at > now;
   }
 
+  public static async release(id: string) {
+    const exist = await this.findByPk(id);
+    if (exist) {
+      await exist.update({ release_at: dayjs().unix() });
+    }
+  }
+
   public static associate() {}
 }
 

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

@@ -130,6 +130,12 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
   declare created_at: CreationOptional<Date>;
   declare updated_at: CreationOptional<Date>;
 
+  declare overdraft_protection?: {
+    enabled: boolean;
+    payment_method_id: string;
+    payment_details: PaymentDetails;
+  };
+
   public static readonly GENESIS_ATTRIBUTES = {
     id: {
       type: DataTypes.STRING(30),
@@ -309,6 +315,15 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
           type: DataTypes.STRING(40),
           allowNull: true,
         },
+        overdraft_protection: {
+          type: DataTypes.JSON,
+          allowNull: true,
+          defaultValue: JSON.stringify({
+            enabled: false,
+            payment_method_id: null,
+            payment_details: null,
+          }),
+        },
       },
       {
         sequelize,

package/api/src/store/sequelize.ts

@@ -7,7 +7,7 @@ import { join } from 'path';
 import CLS from 'cls-hooked';
 import { Sequelize } from 'sequelize';
 
-import env from '../libs/env';
+import env, { sequelizeOptionsPoolIdle, sequelizeOptionsPoolMax, sequelizeOptionsPoolMin } from '../libs/env';
 
 const namespace = CLS.createNamespace('payment-kit');
 
@@ -18,6 +18,11 @@ export const sequelize = new Sequelize({
   dialect: 'sqlite',
   logging: process.env.SQL_LOG === '1',
   storage: join(env.dataDir, 'payment-kit.db'),
+  pool: {
+    min: sequelizeOptionsPoolMin,
+    max: sequelizeOptionsPoolMax,
+    idle: sequelizeOptionsPoolIdle,
+  },
 });
 
 sequelize.query('pragma journal_mode = WAL;');

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