payment-kit 1.15.16 → 1.15.18

package/api/src/libs/queue/index.ts

@@ -5,9 +5,12 @@ import EventEmitter from 'events';
 import fastq from 'fastq';
 import { nanoid } from 'nanoid';
 
+import { AsyncLocalStorage } from 'async_hooks';
 import logger from '../logger';
 import { sleep, tryWithTimeout } from '../util';
 import createQueueStore from './store';
+import { Job } from '../../store/models/job';
+import { sequelize } from '../../store/sequelize';
 
 const CANCELLED = '__CANCELLED__';
 const MIN_DELAY = process.env.NODE_ENV === 'test' ? 2 : 8;
@@ -50,26 +53,56 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
   const getJobId = (id: string | undefined, job: any) => id || (options.id ? options.id(job) : nanoid()) || nanoid();
 
   const queueEvents = new EventEmitter();
+  const asyncLocalStorage = new AsyncLocalStorage();
+  const runningJobs = new Set();
+  const cancelledJobs = new Set();
+
+  const ensureUniqueExecution = async (id: string, fn: () => Promise<any>) => {
+    if (runningJobs.has(id)) {
+      logger.warn('Job already running, skipping', { id });
+      return;
+    }
+
+    runningJobs.add(id);
+    try {
+      await asyncLocalStorage.run({ id }, fn);
+    } finally {
+      runningJobs.delete(id);
+      logger.info(`Running job deleted: ${id}`);
+    }
+  };
+
   const queue = fastq(async ({ job, id, persist }: { job: any; id: string; persist: boolean }, cb: Function) => {
-    if (persist) {
-      try {
-        const cancelled = await store.isCancelled(id);
-        if (cancelled) {
-          cb(null, CANCELLED);
+    logger.info('execute job', { id, job, persist });
+    await ensureUniqueExecution(id, async () => {
+      if (persist) {
+        try {
+          const cancelled = await store.isCancelled(id);
+          if (cancelled) {
+            cb(null, CANCELLED);
+            return;
+          }
+        } catch (err) {
+          cb(err);
           return;
         }
-      } catch (err) {
-        cb(err);
+      }
+
+      if (cancelledJobs.has(id)) {
+        cb(null, CANCELLED);
+        logger.info(`Job skipped because it is cancelled: ${id}`);
+        cancelledJobs.delete(id);
         return;
       }
-    }
 
-    try {
-      const result = await tryWithTimeout(() => onJob(job), maxTimeout);
-      cb(null, result);
-    } catch (err) {
-      cb(err);
-    }
+      try {
+        const result = await tryWithTimeout(() => onJob(job), maxTimeout);
+        logger.info('job finished', { id, result });
+        cb(null, result);
+      } catch (err) {
+        cb(err);
+      }
+    });
     // @ts-ignore
   }, concurrency);
 
@@ -109,7 +142,8 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
       store
         .addJob(jobId, job, attrs)
         .then(() => {
-          emit('queued', { id: jobId, job, attrs });
+          emit('queued', { id: jobId, job, attrs, persist });
+          logger.info('delayed or scheduled job queued', { id: jobId, job, attrs, persist });
         })
         .catch((err) => {
           console.error(err);
@@ -157,7 +191,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
         logger.info('retry job', { id: jobId, count: doc.retry_count + 1 });
         setTimeout(() => {
           emit('retry', { id: jobId, job, doc });
-          queue.unshift({ id: jobId, job }, onJobComplete);
+          queue.unshift({ id: jobId, job, persist }, onJobComplete);
         }, retryDelay);
         // eslint-disable-next-line no-shadow, @typescript-eslint/no-shadow
       } catch (err: any) {
@@ -171,6 +205,9 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
       setImmediate(() => {
         emit('queued', { id: jobId, job, persist });
         logger.info('queue job', { id: jobId, job });
+        if (cancelledJobs.has(jobId)) {
+          cancelledJobs.delete(jobId);
+        }
         queue.push({ id: jobId, job, persist }, onJobComplete);
       });
 
@@ -208,6 +245,7 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
 
   const cancel = async (id: string) => {
     const doc = await store.updateJob(id, { cancelled: true });
+    cancelledJobs.add(id);
     return doc ? doc.job : null;
   };
 
@@ -219,18 +257,26 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
   const deleteJob = async (id: string): Promise<boolean> => {
     const exists = await getJob(id);
 
-    if (exists) {
+    if (!exists) {
+      return false;
+    }
+    try {
       await cancel(id);
       await store.deleteJob(id);
+      logger.info(`Job deleted successfully: ${id}`);
       return true;
+    } catch (error) {
+      console.error(`Error during job deletion process for ${id}:`, error);
+      return false;
     }
-
-    return false;
   };
 
   // Populate the queue on startup
   process.nextTick(async () => {
     try {
+      if (!Job.isInitialized()) {
+        Job.initialize(sequelize);
+      }
       const jobs = await store.getJobs();
       logger.info(`${name} jobs to populate`, { count: jobs.length });
       jobs.forEach((x) => {
@@ -260,6 +306,10 @@ export default function createQueue<T = any>({ name, onJob, options = defaults }
             if (x.job && x.id) {
               // fix: https://github.com/blocklet/payment-kit/issues/287
               await cancel(x.id);
+              logger.info('reschedule delayed or scheduled job', {
+                id: x.id,
+                job: x.job,
+              });
               push({ job: x.job, id: x.id, persist: false });
             } else {
               logger.info('skip invalid job from db', { job: x });

package/api/src/libs/queue/store.ts

@@ -13,7 +13,11 @@ export default function createQueueStore(queue: string) {
       return Job.findOne({ where: { queue, id }, transaction: null });
     },
     getJobs(): Promise<TJob[]> {
-      return Job.findAll({ where: { queue, delay: -1 }, order: [['created_at', 'ASC']], transaction: null });
+      return Job.findAll({
+        where: { queue, delay: -1, cancelled: false },
+        order: [['created_at', 'ASC']],
+        transaction: null,
+      });
     },
     getScheduledJobs(): Promise<TJob[]> {
       return Job.findAll({
@@ -31,12 +35,31 @@ export default function createQueueStore(queue: string) {
       return job.update(updates);
     },
     async addJob(id: string, job: any, attrs: Partial<TJob> = {}): Promise<TJob> {
-      const exist = await Job.findOne({ where: { queue, id }, transaction: null });
-      if (exist) {
-        throw new CustomError('JOB_DUPLICATE', `Job ${queue}#${id} already exist`);
+      const existingJob = await Job.findOne({ where: { id } });
+
+      if (existingJob) {
+        throw new CustomError(
+          'JOB_DUPLICATE',
+          `Job with id ${id} already exists ${existingJob.queue === queue ? 'in the same queue' : `in queue ${existingJob.queue}`}`
+        );
       }
 
-      return Job.create({ id, job, queue, retry_count: 1, cancelled: false, ...attrs });
+      try {
+        const newJob = await Job.create({
+          id,
+          job,
+          queue,
+          retry_count: 1,
+          cancelled: false,
+          ...attrs,
+        });
+        return newJob;
+      } catch (error) {
+        if (error.name === 'SequelizeUniqueConstraintError') {
+          throw new CustomError('JOB_DUPLICATE', `Job with id ${id} was created concurrently`);
+        }
+        throw error;
+      }
     },
     async deleteJob(id: string): Promise<boolean> {
       const data = await Job.destroy({ where: { queue, id } });

package/api/src/libs/subscription.ts

@@ -49,6 +49,40 @@ export function getCustomerSubscriptionPageUrl({
   );
 }
 
+export function getAdminSubscriptionPageUrl({
+  subscriptionId,
+  locale = 'en',
+  userDid,
+}: {
+  subscriptionId: string;
+  locale: LiteralUnion<'en' | 'zh', string>;
+  userDid: string;
+}) {
+  return component.getUrl(
+    withQuery(`admin/billing/${subscriptionId}`, {
+      locale,
+      ...getConnectQueryParam({ userDid }),
+    })
+  );
+}
+
+export function getAdminInvoicePageUrl({
+  invoiceId,
+  locale = 'en',
+  userDid,
+}: {
+  invoiceId: string;
+  locale: LiteralUnion<'en' | 'zh', string>;
+  userDid: string;
+}) {
+  return component.getUrl(
+    withQuery(`admin/billing/${invoiceId}`, {
+      locale,
+      ...getConnectQueryParam({ userDid }),
+    })
+  );
+}
+
 export function parseIntegerConfig(alternatives: any[], defaultValue: number) {
   for (const raw of alternatives) {
     const days = parseInt(raw, 10);
@@ -473,7 +507,7 @@ export async function finalizeSubscriptionUpdate({
 }: {
   subscription: Subscription;
   customer: Customer;
-  invoice: Invoice;
+  invoice: Invoice | null;
   paymentCurrency: PaymentCurrency;
   appliedCredit: string;
   newCredit: string;
@@ -522,27 +556,31 @@ export async function finalizeSubscriptionUpdate({
   // update customer credits
   if (appliedCredit !== '0') {
     const creditResult = await customer.decreaseTokenBalance(paymentCurrency.id, appliedCredit);
-    await invoice.update({
-      starting_token_balance: creditResult.starting,
-      ending_token_balance: creditResult.ending,
-    });
-    logger.info('customer credit applied to invoice after proration', {
-      subscription: subscription.id,
-      appliedCredit,
-      creditResult,
-    });
+    if (invoice) {
+      await invoice.update({
+        starting_token_balance: creditResult.starting,
+        ending_token_balance: creditResult.ending,
+      });
+      logger.info('customer credit applied to invoice after proration', {
+        subscription: subscription.id,
+        appliedCredit,
+        creditResult,
+      });
+    }
   }
   if (newCredit !== '0') {
     const creditResult = await customer.increaseTokenBalance(paymentCurrency.id, newCredit);
-    await invoice.update({
-      starting_token_balance: creditResult.starting,
-      ending_token_balance: creditResult.ending,
-    });
-    logger.info('subscription proration credit applied to customer', {
-      subscription: subscription.id,
-      newCredit,
-      creditResult,
-    });
+    if (invoice) {
+      await invoice.update({
+        starting_token_balance: creditResult.starting,
+        ending_token_balance: creditResult.ending,
+      });
+      logger.info('subscription proration credit applied to customer', {
+        subscription: subscription.id,
+        newCredit,
+        creditResult,
+      });
+    }
   }
 
   // lock for next update
@@ -866,3 +904,75 @@ export async function getSubscriptionStakeCancellation(
   }
   return cancellation;
 }
+
+export async function getSubscriptionStakeAmountSetup(subscription: Subscription, paymentMethod: PaymentMethod) {
+  if (paymentMethod.type !== 'arcblock') {
+    return null;
+  }
+  const txHash = subscription?.payment_details?.arcblock?.staking?.tx_hash;
+  if (!txHash) {
+    return null;
+  }
+  const client = paymentMethod.getOcapClient();
+  const { info } = await client.getTx({ hash: txHash });
+  if (!info) {
+    return null;
+  }
+  // @ts-ignore
+  const inputs = info?.tx?.itxJson?.inputs || [];
+  if (!inputs || inputs.length === 0) {
+    logger.info('getSubscriptionStakeAmountSetup failed, no inputs', { txHash, info });
+    return null;
+  }
+  const amountRes: { [key: string]: BN } = {};
+  // calculate stake amount for each address
+  inputs.forEach((input: any) => {
+    const { tokens } = input;
+    tokens.forEach((token: any) => {
+      const { address, value } = token;
+      if (amountRes[address]) {
+        amountRes[address] = amountRes[address].add(new BN(value));
+      } else {
+        amountRes[address] = new BN(value);
+      }
+    });
+  });
+  Object.keys(amountRes).forEach((address) => {
+    amountRes[address] = amountRes[address].toString();
+  });
+  logger.info('get subscription stake amount setup success', { txHash, amountRes });
+  return amountRes;
+}
+
+// check if usage report is empty
+export async function checkUsageReportEmpty(
+  subscription: Subscription,
+  usageReportStart: number,
+  usageReportEnd: number
+) {
+  const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
+  const expandedItems = await Price.expand(
+    subscriptionItems.map((x) => ({ id: x.id, price_id: x.price_id, quantity: x.quantity })),
+    { product: true }
+  );
+  const meteredItems = expandedItems.filter((x: any) => x?.price?.recurring?.usage_type === 'metered');
+  if (meteredItems.length === 0) {
+    return false;
+  }
+  const usageReportEmpty = await Promise.all(
+    meteredItems.map(async (x: any) => {
+      const usageRecords = await UsageRecord.findAll({
+        where: {
+          subscription_item_id: x.id,
+          billed: false,
+          timestamp: {
+            [Op.gt]: usageReportStart,
+            [Op.lte]: usageReportEnd,
+          },
+        },
+      });
+      return usageRecords.length === 0;
+    })
+  );
+  return usageReportEmpty.every(Boolean);
+}

package/api/src/libs/util.ts

@@ -10,6 +10,8 @@ import { joinURL, withQuery } from 'ufo';
 
 import dayjs from './dayjs';
 import { blocklet, wallet } from './auth';
+import type { Subscription } from '../store/models';
+import logger from './logger';
 
 export const OCAP_PAYMENT_TX_TYPE = 'fg:t:transfer_v2';
 
@@ -289,3 +291,31 @@ export function getCustomerProfileUrl({
     })
   );
 }
+
+export async function getOwnerDid() {
+  try {
+    const { user } = await blocklet.getOwner();
+    return user?.did;
+  } catch (error) {
+    logger.error('getOwnerDid error', error);
+    return undefined;
+  }
+}
+
+export function getSubscriptionNotificationCustomActions(
+  subscription: Subscription,
+  eventType: string,
+  locale: string
+) {
+  if (!subscription || !subscription?.service_actions || !subscription?.service_actions?.length) {
+    return [];
+  }
+  const actions = subscription.service_actions?.filter(
+    (x: any) => x?.type === 'notification' && x?.triggerEvents?.includes(eventType)
+  );
+  return actions?.map((x: any) => ({
+    name: x?.name || x?.text?.[locale],
+    title: x?.text?.[locale],
+    link: x?.link,
+  }));
+}

package/api/src/locales/en.ts

@@ -45,6 +45,14 @@ export default flat({
       qty: '{count} unit',
       failReason: 'Failure reason',
       balanceReminder: 'Balance reminder',
+      subscriptionId: 'Subscription ID',
+      shouldPayAmount: 'Should pay amount',
+      billedAmount: 'Billed amount',
+    },
+
+    billingDiscrepancy: {
+      title: '{productName} billing discrepancy',
+      body: 'Detected billing discrepancy for {productName}, please check.',
     },
 
     sendTo: 'Sent to',
@@ -53,6 +61,11 @@ export default flat({
       message: 'A new {collection} NFT is minted and sent to your wallet, please check it out.',
     },
 
+    usageReportEmpty: {
+      title: 'No usage report for {productName}',
+      body: 'No usage report for {productName} detected, please check.',
+    },
+
     subscriptionTrialStart: {
       title: 'Welcome to the start of your {productName} trial',
       body: 'Congratulations on your {productName} trial! The length of the trial is {trialDuration} and will end at {subscriptionTrialEnd}. Have fun with {productName}!',

package/api/src/locales/zh.ts

@@ -45,6 +45,9 @@ export default flat({
       qty: '{count} 件',
       failReason: '失败原因',
       balanceReminder: '余额提醒',
+      subscriptionId: '订阅 ID',
+      shouldPayAmount: '应收金额',
+      billedAmount: '实缴金额',
     },
 
     sendTo: '发送给',
@@ -53,6 +56,16 @@ export default flat({
       message: '{collection} NFT 已经铸造完成并发送到你的钱包，请查收',
     },
 
+    usageReportEmpty: {
+      title: '{productName} 未上报用量',
+      body: '检测到 {productName} 未上报用量，请留意。',
+    },
+
+    billingDiscrepancy: {
+      title: '{productName} 账单金额核算不一致',
+      body: '检测到 {productName} 账单金额核算不一致，请留意。',
+    },
+
     subscriptionTrialStart: {
       title: '欢迎开始您的 {productName} 试用之旅',
       body: '恭喜您获得了 {productName} 的试用资格！试用期时长为 {trialDuration}，将于 {subscriptionTrialEnd} 结束。祝您使用愉快！',

package/api/src/queues/invoice.ts

@@ -1,17 +1,20 @@
 import { Op } from 'sequelize';
 
+import { getInvoiceShouldPayTotal } from '@api/libs/invoice';
 import { batchHandleStripeInvoices } from '../integrations/stripe/resource';
 import { createEvent } from '../libs/audit';
 import dayjs from '../libs/dayjs';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { PaymentMethod } from '../store/models';
+import { PaymentMethod, Invoice } from '../store/models';
 import { CheckoutSession } from '../store/models/checkout-session';
-import { Invoice } from '../store/models/invoice';
 import { PaymentIntent } from '../store/models/payment-intent';
 import { Subscription } from '../store/models/subscription';
 import { paymentQueue } from './payment';
 
+import { getLock } from '../libs/lock';
+import { events } from '../libs/event';
+
 type InvoiceJob = {
   invoiceId: string;
   justCreate?: boolean;
@@ -195,28 +198,63 @@ export const invoiceQueue = createQueue<InvoiceJob>({
 });
 
 export const startInvoiceQueue = async () => {
-  const invoices = await Invoice.findAll({
-    where: {
-      status: 'open',
-      collection_method: 'charge_automatically',
-      amount_remaining: { [Op.gt]: '0' },
-    },
-  });
-
-  invoices.forEach(async (x) => {
-    const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
-    if (supportAutoCharge === false) {
-      return;
-    }
-    const exist = await invoiceQueue.get(x.id);
-    if (!exist) {
-      invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });
+  const lock = getLock('startInvoiceQueue');
+  if (lock.locked) {
+    return;
+  }
+
+  try {
+    await lock.acquire();
+    const invoices = await Invoice.findAll({
+      where: {
+        status: 'open',
+        collection_method: 'charge_automatically',
+        amount_remaining: { [Op.gt]: '0' },
+      },
+    });
+
+    const results = await Promise.allSettled(
+      invoices.map(async (x) => {
+        const supportAutoCharge = await PaymentMethod.supportAutoCharge(x.default_payment_method_id);
+        if (supportAutoCharge === false) {
+          return;
+        }
+        const exist = await invoiceQueue.get(x.id);
+        if (!exist) {
+          await invoiceQueue.push({ id: x.id, job: { invoiceId: x.id, retryOnError: true } });
+        }
+      })
+    );
+
+    const failed = results.filter((r) => r.status === 'rejected').length;
+    if (failed > 0) {
+      logger.warn(`Failed to process ${failed} invoices in startInvoiceQueue`);
     }
-  });
 
-  await batchHandleStripeInvoices();
+    await batchHandleStripeInvoices();
+  } catch (error) {
+    logger.error('Error in startInvoiceQueue:', error);
+  } finally {
+    lock.release();
+  }
 };
 
 invoiceQueue.on('failed', ({ id, job, error }) => {
   logger.error('Invoice job failed', { id, job, error });
 });
+
+events.on('invoice.paid', async ({ id: invoiceId }) => {
+  const invoice = await Invoice.findByPk(invoiceId);
+  if (!invoice) {
+    logger.error('Invoice not found', { invoiceId });
+    return;
+  }
+  const checkBillingReason = ['subscription_cycle', 'subscription_cancel'];
+  if (checkBillingReason.includes(invoice.billing_reason)) {
+    const shouldPayTotal = await getInvoiceShouldPayTotal(invoice);
+    if (shouldPayTotal !== invoice.total) {
+      createEvent('Invoice', 'billing.discrepancy', invoice);
+      logger.info('create billing discrepancy event', { invoiceId, shouldPayTotal, invoiceTotal: invoice.total });
+    }
+  }
+});

package/api/src/queues/notification.ts

@@ -57,6 +57,14 @@ import {
 } from '../libs/notification/template/subscription-stake-slash-succeeded';
 import createQueue from '../libs/queue';
 import { CheckoutSession, EventType, Invoice, PaymentLink, Refund, Subscription } from '../store/models';
+import {
+  UsageReportEmptyEmailTemplate,
+  UsageReportEmptyEmailTemplateOptions,
+} from '../libs/notification/template/usage-report-empty';
+import {
+  BillingDiscrepancyEmailTemplate,
+  BillingDiscrepancyEmailTemplateOptions,
+} from '../libs/notification/template/billing-discrepancy';
 
 export type NotificationQueueJobOptions = any;
 
@@ -65,7 +73,9 @@ export type NotificationQueueJobType =
   | 'customer.subscription.will_renew'
   | 'customer.subscription.trial_will_end'
   | 'customer.subscription.will_canceled'
-  | 'customer.reward.succeeded';
+  | 'customer.reward.succeeded'
+  | 'usage.report.empty'
+  | 'billing.discrepancy';
 
 export type NotificationQueueJob = {
   type: NotificationQueueJobType;
@@ -73,6 +83,12 @@ export type NotificationQueueJob = {
 };
 
 function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
+  if (job.type === 'usage.report.empty') {
+    return new UsageReportEmptyEmailTemplate(job.options as UsageReportEmptyEmailTemplateOptions);
+  }
+  if (job.type === 'billing.discrepancy') {
+    return new BillingDiscrepancyEmailTemplate(job.options as BillingDiscrepancyEmailTemplateOptions);
+  }
   if (job.type === 'customer.subscription.started') {
     return new SubscriptionSucceededEmailTemplate(job.options as SubscriptionSucceededEmailTemplateOptions);
   }
@@ -275,4 +291,30 @@ export async function startNotificationQueue() {
       },
     });
   });
+
+  events.on('usage.report.empty', (subscription: Subscription, { usageReportStart, usageReportEnd }) => {
+    notificationQueue.push({
+      id: `usage.report.empty.${subscription.id}`,
+      job: {
+        type: 'usage.report.empty',
+        options: {
+          subscriptionId: subscription.id,
+          usageReportStart,
+          usageReportEnd,
+        },
+      },
+    });
+  });
+
+  events.on('billing.discrepancy', (invoice: Invoice) => {
+    notificationQueue.push({
+      id: `billing.discrepancy.${invoice.id}`,
+      job: {
+        type: 'billing.discrepancy',
+        options: {
+          invoiceId: invoice.id,
+        },
+      },
+    });
+  });
 }

package/api/src/queues/payment.ts

@@ -210,7 +210,7 @@ export const handlePaymentSucceed = async (
         }
       }
 
-      if (triggerRenew) {
+      if (triggerRenew && invoice.billing_reason !== 'subscription_update') {
         if (invoice.billing_reason === 'subscription_cycle' || paymentIntent.capture_method === 'manual') {
           createEvent('Subscription', 'customer.subscription.renewed', subscription).catch(console.error);
         }
@@ -323,6 +323,10 @@ export const handlePaymentFailed = async (
     return updates.terminate;
   }
 
+  if (subscription.isImmutable()) {
+    logger.info('Subscription is immutable, no need to check due', { subscription: subscription.id });
+    return updates.terminate;
+  }
   // check days until cancel
   const dueUnit = getDueUnit(interval);
   const daysUntilCancel = getDaysUntilCancel(subscription);