payment-kit 1.18.46 → 1.18.48

package/api/src/routes/invoices.ts

@@ -23,6 +23,7 @@ import { Product } from '../store/models/product';
 import { Subscription } from '../store/models/subscription';
 import { getReturnStakeInvoices, getStakingInvoices, retryUncollectibleInvoices } from '../libs/invoice';
 import { CheckoutSession, PaymentLink, TInvoiceExpanded } from '../store/models';
+import { mergePaginate, defaultTimeOrderBy, getCachedOrFetch, DataSource } from '../libs/pagination';
 import logger from '../libs/logger';
 
 const router = Router();
@@ -38,6 +39,99 @@ const authPortal = authenticate<Invoice>({
   },
 });
 
+// Helper function: Get staking invoices by subscription ID with error handling
+async function getStakingInvoicesById(subscriptionId: string) {
+  try {
+    const subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) return [];
+    return await getStakingInvoices(subscription);
+  } catch (error) {
+    logger.error('Failed to get staking invoices by ID', { error, subscriptionId });
+    return [];
+  }
+}
+
+// Helper function: Get return stake invoices by subscription ID with error handling
+async function getReturnStakeInvoicesById(subscriptionId: string) {
+  try {
+    const subscription = await Subscription.findByPk(subscriptionId);
+    if (!subscription) return [];
+    return await getReturnStakeInvoices(subscription);
+  } catch (error) {
+    logger.error('Failed to get return stake invoices by ID', { error, subscriptionId });
+    return [];
+  }
+}
+
+// Helper function: Create data sources for recover-from subscriptions (with cache)
+function createRecoverFromSubscriptionSources(
+  recoverFromSubscriptionIds: string[],
+  include_staking: boolean | undefined,
+  include_return_staking: boolean | undefined
+): DataSource<Invoice>[] {
+  const sources: DataSource<Invoice>[] = [];
+
+  for (const id of recoverFromSubscriptionIds) {
+    if (include_staking) {
+      sources.push({
+        count: async () => {
+          try {
+            const invoices = await getCachedOrFetch(`staking:${id}`, () => getStakingInvoicesById(id));
+            return invoices.length;
+          } catch (error) {
+            logger.error('Failed to count cached staking invoices', { error, subscriptionId: id });
+            return 0;
+          }
+        },
+        fetch: async (limit: number, offset: number = 0) => {
+          try {
+            const invoices = await getCachedOrFetch(`staking:${id}`, () => getStakingInvoicesById(id));
+            return invoices.slice(offset, offset + limit);
+          } catch (error) {
+            logger.error('Failed to fetch cached staking invoices', { error, subscriptionId: id });
+            return [];
+          }
+        },
+        meta: {
+          type: 'cached' as const,
+          estimatedSize: 50,
+          cacheable: true,
+        },
+      });
+    }
+
+    if (include_return_staking) {
+      sources.push({
+        count: async () => {
+          try {
+            const invoices = await getCachedOrFetch(`return-staking:${id}`, () => getReturnStakeInvoicesById(id));
+            return invoices.length;
+          } catch (error) {
+            logger.error('Failed to count cached return stake invoices', { error, subscriptionId: id });
+            return 0;
+          }
+        },
+        fetch: async (limit: number, offset: number = 0) => {
+          try {
+            const invoices = await getCachedOrFetch(`return-staking:${id}`, () => getReturnStakeInvoicesById(id));
+            return invoices.slice(offset, offset + limit);
+          } catch (error) {
+            logger.error('Failed to fetch cached return stake invoices', { error, subscriptionId: id });
+            return [];
+          }
+        },
+        meta: {
+          type: 'cached' as const,
+          estimatedSize: 50,
+          cacheable: true,
+        },
+      });
+    }
+  }
+
+  return sources;
+}
+
 const schema = createListParamSchema<{
   status?: string;
   customer_id?: string;
@@ -61,122 +155,220 @@ const schema = createListParamSchema<{
   include_overdraft_protection: Joi.boolean().default(true),
   include_recovered_from: Joi.boolean().empty(false),
 });
+
 router.get('/', authMine, async (req, res) => {
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  const {
-    page,
-    pageSize,
-    livemode,
-    status,
-    ignore_zero,
-    include_staking,
-    include_return_staking,
-    include_overdraft_protection = true,
-    ...query
-  } = await schema.validateAsync(req.query, {
-    stripUnknown: false,
-    allowUnknown: true,
-  });
-  const where = getWhereFromKvQuery(query.q);
+  try {
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const {
+      page,
+      pageSize,
+      livemode,
+      status,
+      ignore_zero,
+      include_staking,
+      include_return_staking,
+      include_overdraft_protection = true,
+      ...query
+    } = await schema.validateAsync(req.query, {
+      stripUnknown: false,
+      allowUnknown: true,
+    });
 
-  if (status) {
-    where.status = status
-      .split(',')
-      .map((x) => x.trim())
-      .filter(Boolean);
-  }
-  if (ignore_zero) {
-    where.total = { [Op.ne]: '0' };
-  }
-  if (query.customer_id) {
-    where.customer_id = query.customer_id;
-  }
-  if (query.currency_id) {
-    where.currency_id = query.currency_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: [], paging: { page, pageSize } });
-      return;
+    const where = getWhereFromKvQuery(query.q);
+
+    if (status) {
+      where.status = status
+        .split(',')
+        .map((x) => x.trim())
+        .filter(Boolean);
     }
-  }
-  if (query.subscription_id) {
-    if (query.include_recovered_from) {
-      where.subscription_id = [query.subscription_id].concat(
-        await Subscription.getFromSubscriptions(query.subscription_id)
-      );
-    } else {
-      where.subscription_id = query.subscription_id;
+    if (ignore_zero) {
+      where.total = { [Op.ne]: '0' };
+    }
+    if (query.customer_id) {
+      where.customer_id = query.customer_id;
+    }
+    if (query.currency_id) {
+      where.currency_id = query.currency_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: [], paging: { page, pageSize } });
+        return;
+      }
+    }
+    if (query.subscription_id) {
+      if (query.include_recovered_from) {
+        where.subscription_id = [query.subscription_id].concat(
+          await Subscription.getFromSubscriptions(query.subscription_id)
+        );
+      } else {
+        where.subscription_id = query.subscription_id;
+      }
+    }
+    if (typeof livemode === 'boolean') {
+      where.livemode = livemode;
     }
-  }
-  if (typeof livemode === 'boolean') {
-    where.livemode = livemode;
-  }
 
-  Object.keys(query)
-    .filter((x) => x.startsWith('metadata.'))
-    .forEach((key: string) => {
-      // @ts-ignore
-      where[key] = query[key];
-    });
+    Object.keys(query)
+      .filter((x) => x.startsWith('metadata.'))
+      .forEach((key: string) => {
+        // @ts-ignore
+        where[key] = query[key];
+      });
 
-  const excludeBillingReasons = ['recharge'];
-  if (!include_overdraft_protection) {
-    excludeBillingReasons.push('stake_overdraft_protection');
-  }
-  if (!!(include_staking && query.subscription_id) || !include_staking) {
-    excludeBillingReasons.push('stake');
-  }
-  if (excludeBillingReasons.length > 0) {
-    where.billing_reason = { [Op.notIn]: excludeBillingReasons };
-  }
-  try {
-    const { rows: list, count } = await Invoice.findAndCountAll({
-      where,
-      order: getOrder(req.query, [['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: Subscription, as: 'subscription', attributes: ['id', 'description'] },
-        { model: Customer, as: 'customer' },
-      ],
+    const excludeBillingReasons = ['recharge'];
+    if (!include_overdraft_protection) {
+      excludeBillingReasons.push('stake_overdraft_protection');
+    }
+    if (!!(include_staking && query.subscription_id) || !include_staking) {
+      excludeBillingReasons.push('stake');
+    }
+    if (excludeBillingReasons.length > 0) {
+      where.billing_reason = { [Op.notIn]: excludeBillingReasons };
+    }
+
+    // Build data sources with proper metadata
+    const sources: DataSource<Invoice>[] = [];
+
+    // Primary data source: Invoice database records
+    sources.push({
+      count: () => {
+        return Invoice.count({ where });
+      },
+      fetch: async (limit: number, offset: number = 0) => {
+        const result = await Invoice.findAll({
+          where,
+          order: getOrder(req.query, [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']]),
+          limit,
+          offset,
+          include: [
+            { model: PaymentCurrency, as: 'paymentCurrency' },
+            { model: PaymentMethod, as: 'paymentMethod' },
+            { model: Subscription, as: 'subscription', attributes: ['id', 'description'] },
+            { model: Customer, as: 'customer' },
+          ],
+        });
+        return result;
+      },
+      meta: {
+        type: 'database' as const,
+        cacheable: false,
+      },
     });
 
-    // push staking info as first invoice if we are on the last page
-    let subscription;
-    let invoices = list;
-    if (query.subscription_id && include_staking && page === Math.ceil((count || 1) / pageSize)) {
-      try {
-        subscription = await Subscription.findByPk(query.subscription_id);
-        if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
-          const stakingInvoices = await getStakingInvoices(subscription);
-          let returnStakeInvoices: any[] = [];
-          if (include_return_staking) {
-            returnStakeInvoices = await getReturnStakeInvoices(subscription);
-          }
-          invoices = [...(stakingInvoices || []), ...(returnStakeInvoices || []), ...list]
-            .filter(Boolean)
-            .sort((a, b) =>
-              query.o === 'asc'
-                ? new Date(a.created_at).getTime() - new Date(b.created_at).getTime()
-                : new Date(b.created_at).getTime() - new Date(a.created_at).getTime()
-            );
+    // Handle subscription_id array
+    let subscriptionIds: string[] = [];
+    if (Array.isArray(where.subscription_id)) {
+      subscriptionIds = where.subscription_id;
+    } else if (where.subscription_id) {
+      subscriptionIds = [where.subscription_id];
+    }
+
+    // Process active subscription (no cache) - only if staking options are enabled
+    const activeSubscriptionId = subscriptionIds[0];
+    if (include_staking && activeSubscriptionId) {
+      const subscription = await Subscription.findByPk(activeSubscriptionId);
+      if (subscription?.payment_details?.arcblock?.staking?.tx_hash) {
+        // Add staking invoices source
+        if (include_staking) {
+          sources.push({
+            count: async () => {
+              try {
+                const invoices = await getStakingInvoices(subscription);
+                return invoices.length;
+              } catch (error) {
+                logger.error('Failed to count staking invoices', { error, subscriptionId: activeSubscriptionId });
+                return 0;
+              }
+            },
+            fetch: async (limit: number, offset: number = 0) => {
+              try {
+                const invoices = await getStakingInvoices(subscription);
+                return invoices.slice(offset, offset + limit);
+              } catch (error) {
+                logger.error('Failed to fetch staking invoices', { error, subscriptionId: activeSubscriptionId });
+                return [];
+              }
+            },
+            meta: {
+              type: 'computed' as const,
+              estimatedSize: 50, // Most staking invoices are small
+              cacheable: true,
+            },
+          });
+        }
+
+        // Add return stake invoices source
+        if (include_return_staking) {
+          sources.push({
+            count: async () => {
+              try {
+                const invoices = await getReturnStakeInvoices(subscription);
+                return invoices.length;
+              } catch (error) {
+                logger.error('Failed to count return stake invoices', { error, subscriptionId: activeSubscriptionId });
+                return 0;
+              }
+            },
+            fetch: async (limit: number, offset: number = 0) => {
+              try {
+                const invoices = await getReturnStakeInvoices(subscription);
+                return invoices.slice(offset, offset + limit);
+              } catch (error) {
+                logger.error('Failed to fetch return stake invoices', { error, subscriptionId: activeSubscriptionId });
+                return [];
+              }
+            },
+            meta: {
+              type: 'computed' as const,
+              estimatedSize: 50, // Return stake invoices are usually fewer
+              cacheable: true,
+            },
+          });
         }
-      } catch (err) {
-        console.error('Failed to include staking record in invoice list', err);
       }
     }
 
-    res.json({ count, list: invoices, subscription, paging: { page, pageSize } });
+    // Process recover-from subscriptions (with cache) - only if staking options are enabled
+    const recoverFromSubscriptionIds = subscriptionIds.slice(1);
+    if (include_staking && recoverFromSubscriptionIds.length > 0) {
+      const recoverFromSources = createRecoverFromSubscriptionSources(
+        recoverFromSubscriptionIds,
+        include_staking,
+        include_return_staking
+      );
+      sources.push(...recoverFromSources);
+    }
+
+    // Use generic pagination with intelligent strategy
+    const result = await mergePaginate(
+      sources,
+      { page: Number(page), pageSize: Number(pageSize) },
+      defaultTimeOrderBy(query.o === 'asc' ? 'asc' : 'desc')
+    );
+
+    res.json({
+      count: result.total,
+      list: result.data,
+      paging: result.paging,
+    });
   } catch (err) {
-    logger.error(err);
-    res.json({ count: 0, list: [], paging: { page, pageSize } });
+    logger.error('Failed to fetch invoices', {
+      error: err,
+      page: req.query.page,
+      pageSize: req.query.pageSize,
+      include_staking: req.query.include_staking,
+      subscription_id: req.query.subscription_id,
+    });
+    res.json({
+      count: 0,
+      list: [],
+      paging: { page: Number(req.query.page || 1), pageSize: Number(req.query.pageSize || 10) },
+    });
   }
 });
 

package/api/src/routes/subscriptions.ts

@@ -17,6 +17,7 @@ import { isDelegationSufficientForPayment } from '../libs/payment';
 import { authenticate } from '../libs/security';
 import { expandLineItems, getFastCheckoutAmount, getSubscriptionCreateSetup, isLineItemAligned } from '../libs/session';
 import {
+  checkRemainingStake,
   createProration,
   finalizeSubscriptionUpdate,
   getPastInvoicesAmount,
@@ -33,6 +34,7 @@ import { invoiceQueue } from '../queues/invoice';
 import {
   addSubscriptionJob,
   returnOverdraftProtectionQueue,
+  returnStakeQueue,
   slashOverdraftProtectionQueue,
   slashStakeQueue,
   subscriptionQueue,
@@ -426,6 +428,42 @@ router.put('/:id/cancel', authPortal, async (req, res) => {
   return res.json(subscription);
 });
 
+router.get('/:id/recover-info', authPortal, async (req, res) => {
+  const doc = await Subscription.findByPk(req.params.id);
+
+  if (!doc) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(doc.default_payment_method_id);
+  const paymentCurrency = await PaymentCurrency.findByPk(doc.currency_id);
+
+  let needStake = false;
+  let revokedStake = '0';
+
+  if (paymentMethod?.type === 'arcblock' && paymentCurrency) {
+    const address = doc.payment_details?.arcblock?.staking?.address;
+    if (address) {
+      try {
+        const { revoked } = await checkRemainingStake(paymentMethod, paymentCurrency, address, '0');
+        const cancelReason = doc.cancelation_details?.reason;
+        if (revoked && revoked !== '0' && cancelReason === 'stake_revoked') {
+          needStake = true;
+          revokedStake = revoked;
+        }
+      } catch (err) {
+        console.error(`Failed to check remaining stake for subscription ${doc.id}`, { error: err });
+      }
+    }
+  }
+
+  return res.json({
+    subscription: doc,
+    needStake,
+    revokedStake,
+  });
+});
+
 router.put('/:id/recover', authPortal, async (req, res) => {
   const doc = await Subscription.findByPk(req.params.id);
 
@@ -442,13 +480,43 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     return res.status(400).json({ error: 'Subscription not recoverable from cancellation' });
   }
 
+  const paymentMethod = await PaymentMethod.findByPk(doc.default_payment_method_id);
+  if (!paymentMethod) {
+    return res.status(400).json({ error: 'Payment method not found' });
+  }
+  const paymentCurrency = await PaymentCurrency.findByPk(doc.currency_id);
+  if (!paymentCurrency) {
+    return res.status(400).json({ error: 'Payment currency not found' });
+  }
+
+  // check if need stake
+  if (paymentMethod.type === 'arcblock') {
+    const address = doc.payment_details?.arcblock?.staking?.address;
+    if (address) {
+      try {
+        const { revoked } = await checkRemainingStake(paymentMethod, paymentCurrency, address, '0');
+        const cancelReason = doc.cancelation_details?.reason;
+        if (revoked && revoked !== '0' && cancelReason === 'stake_revoked') {
+          return res.json({
+            needStake: true,
+            subscription: doc,
+            revoked,
+          });
+        }
+      } catch (err) {
+        logger.error('subscription recover failed to check remaining stake', { error: err });
+      }
+    }
+  }
+
   if (doc.cancel_at_period_end) {
     await updateStripeSubscription(doc, { cancel_at_period_end: false });
   } else {
     await updateStripeSubscription(doc, { cancel_at: null });
   }
 
-  await doc.update({ cancel_at_period_end: false, cancel_at: 0, canceled_at: 0 });
+  // @ts-ignore
+  await doc.update({ cancel_at_period_end: false, cancel_at: 0, canceled_at: 0, cancelation_details: null });
   await new SubscriptionWillCanceledSchedule().deleteScheduleSubscriptionJobs([doc]);
   // reschedule jobs
   subscriptionQueue
@@ -457,7 +525,7 @@ router.put('/:id/recover', authPortal, async (req, res) => {
     .catch((err) => logger.error('subscription cancel job failed to cancel', { error: err }));
   await addSubscriptionJob(doc, 'cycle');
 
-  return res.json(doc);
+  return res.json({ subscription: doc });
 });
 
 router.put('/:id/pause', auth, async (req, res) => {
@@ -520,6 +588,26 @@ router.put('/:id/resume', auth, async (req, res) => {
   return res.json(doc);
 });
 
+router.put('/:id/return-stake', authPortal, async (req, res) => {
+  const doc = await Subscription.findByPk(req.params.id);
+  if (!doc) {
+    return res.status(404).json({ error: 'Subscription not found' });
+  }
+  if (doc.status !== 'canceled') {
+    return res.status(400).json({ error: 'Subscription is not canceled' });
+  }
+
+  if (!doc.payment_details?.arcblock?.staking?.tx_hash) {
+    return res.status(400).json({ error: 'No staking transaction found in subscription' });
+  }
+  returnStakeQueue.push({ id: `return-stake-${doc.id}`, job: { subscriptionId: doc.id } });
+  logger.info('Subscription return stake job scheduled', {
+    jobId: `return-stake-${doc.id}`,
+    subscription: doc.id,
+  });
+  return res.json({ success: true, subscriptionId: doc.id });
+});
+
 const isValidSubscriptionItemChange = (item: SubscriptionUpdateItem) => {
   if (item.deleted) {
     if (!item.id) {