payment-kit 1.18.56 → 1.19.1

package/api/src/queues/credit-grant.ts

@@ -0,0 +1,572 @@
+// create credit grant
+
+import { Op } from 'sequelize';
+import { BN, fromTokenToUnit } from '@ocap/util';
+import dayjs from '../libs/dayjs';
+import createQueue from '../libs/queue';
+import {
+  CreditGrant,
+  Customer,
+  Invoice,
+  InvoiceItem,
+  PaymentCurrency,
+  Price,
+  Product,
+  TInvoiceExpanded,
+  TPaymentCurrency,
+  TPriceExpanded,
+} from '../store/models';
+import { events } from '../libs/event';
+import { calculateExpiresAt, createCreditGrant } from '../libs/credit-grant';
+import logger from '../libs/logger';
+
+type CreditGrantJob =
+  | {
+      creditGrantId: string;
+      action: 'activate' | 'expire';
+    }
+  | {
+      invoiceId: string;
+      action: 'create_from_invoice';
+    };
+
+const handleCreditGrantJob = async (job: CreditGrantJob) => {
+  logger.info('Handling credit grant job', { job });
+  if (job.action === 'create_from_invoice') {
+    await handleInvoiceCredit(job.invoiceId);
+    return;
+  }
+
+  const { creditGrantId, action } = job as { creditGrantId: string; action: 'activate' | 'expire' };
+
+  const creditGrant = await CreditGrant.findByPk(creditGrantId);
+  if (!creditGrant) {
+    logger.error('Credit grant not found', { creditGrantId });
+    return;
+  }
+
+  const now = dayjs().unix();
+
+  if (action === 'activate') {
+    if (creditGrant.status !== 'pending') {
+      logger.warn('Credit grant not in pending status for activation', {
+        creditGrantId,
+        status: creditGrant.status,
+      });
+      return;
+    }
+    if (creditGrant.status === 'granted') {
+      logger.info('Credit grant already granted', {
+        creditGrantId,
+      });
+      return;
+    }
+    if (
+      (!creditGrant.effective_at || creditGrant.effective_at <= now) &&
+      (!creditGrant.expires_at || creditGrant.expires_at > now)
+    ) {
+      await creditGrant.update({
+        status: 'granted',
+      });
+
+      logger.info('Credit grant activated', {
+        creditGrantId,
+      });
+
+      if (creditGrant.expires_at) {
+        await addCreditGrantJob(creditGrant, 'expire', creditGrant.expires_at);
+        logger.info('Credit grant expire job scheduled', {
+          creditGrantId,
+          expiresAt: creditGrant.expires_at,
+        });
+      }
+    }
+  }
+
+  if (action === 'expire') {
+    // 检查是否到了过期时间
+    if (creditGrant.status === 'expired') {
+      logger.info('Credit grant already expired', {
+        creditGrantId,
+      });
+      return;
+    }
+    if (creditGrant.expires_at && creditGrant.expires_at <= now) {
+      await creditGrant.update({
+        status: 'expired',
+      });
+      logger.info('Credit grant expired', {
+        creditGrantId,
+      });
+    }
+  }
+};
+
+export const creditGrantQueue = createQueue<CreditGrantJob>({
+  name: 'credit-grant',
+  onJob: handleCreditGrantJob,
+  options: {
+    concurrency: 5,
+    maxRetries: 5,
+    retryDelay: 5000,
+    enableScheduledJob: true,
+  },
+});
+
+// 添加信用授予任务
+export async function addCreditGrantJob(creditGrant: CreditGrant, action: 'activate' | 'expire', runAt?: number) {
+  const jobId = `${action}-${creditGrant.id}`;
+
+  let scheduledTime: number | undefined;
+  if (action === 'activate') {
+    scheduledTime = runAt || creditGrant.effective_at;
+  }
+  if (action === 'expire') {
+    scheduledTime = runAt || creditGrant.expires_at;
+  }
+
+  if (!scheduledTime) {
+    logger.warn(`No scheduled time for credit grant ${action}`, {
+      creditGrantId: creditGrant.id,
+      action,
+      effective_at: creditGrant.effective_at,
+      expires_at: creditGrant.expires_at,
+    });
+    return;
+  }
+
+  const existingJob = await creditGrantQueue.get(jobId);
+  if (existingJob) {
+    await creditGrantQueue.delete(jobId);
+    logger.info(`Credit grant ${action} job replaced`, { creditGrantId: creditGrant.id });
+  }
+
+  await creditGrantQueue.push({
+    id: jobId,
+    job: {
+      creditGrantId: creditGrant.id,
+      action,
+    },
+    runAt: scheduledTime,
+    persist: true,
+  });
+
+  logger.info(`Credit grant ${action} job scheduled`, {
+    creditGrantId: creditGrant.id,
+    action,
+    runAt: scheduledTime,
+    scheduledAt: dayjs.unix(scheduledTime).format(),
+  });
+}
+
+export async function scheduleCreditGrantJobs(creditGrant: CreditGrant) {
+  const now = dayjs().unix();
+
+  if (creditGrant.status === 'pending') {
+    if (creditGrant.effective_at && creditGrant.effective_at > now) {
+      await addCreditGrantJob(creditGrant, 'activate');
+      return;
+    }
+    if (!creditGrant.effective_at || creditGrant.effective_at <= now) {
+      if (!creditGrant.expires_at || creditGrant.expires_at > now) {
+        await creditGrant.update({ status: 'granted' });
+        logger.info('Credit grant immediately activated', {
+          creditGrantId: creditGrant.id,
+          customerId: creditGrant.customer_id,
+        });
+        if (creditGrant.expires_at) {
+          await addCreditGrantJob(creditGrant, 'expire');
+        }
+      } else {
+        await creditGrant.update({ status: 'expired' });
+        logger.info('Credit grant immediately expired', {
+          creditGrantId: creditGrant.id,
+          customerId: creditGrant.customer_id,
+        });
+      }
+    }
+  }
+  if (creditGrant.status === 'granted' && creditGrant.expires_at) {
+    await addCreditGrantJob(creditGrant, 'expire');
+  }
+}
+
+export const startCreditGrantQueue = async () => {
+  logger.info('Starting credit grant queue...');
+
+  const grantsToSchedule = await CreditGrant.findAll({
+    where: {
+      [Op.or]: [
+        { status: 'pending' },
+        {
+          status: 'granted',
+          expires_at: { [Op.gt]: 0 },
+        },
+      ],
+    },
+    order: [['created_at', 'ASC']],
+  });
+
+  const invoicesToSchedule = await Invoice.findAll({
+    where: {
+      status: 'paid',
+      metadata: {
+        credit_grant_processed: 'failed',
+      },
+    },
+    order: [['created_at', 'ASC']],
+  });
+
+  const invoiceResults = await Promise.allSettled(
+    invoicesToSchedule.map(async (invoice) => {
+      await addInvoiceCreditJob(invoice.id);
+      return invoice.id;
+    })
+  );
+
+  const failedInvoices = invoiceResults.filter((r) => r.status === 'rejected').map((r) => r.reason);
+  if (failedInvoices.length > 0) {
+    logger.warn(`Failed to schedule jobs for ${failedInvoices.length} invoices`, {
+      failedInvoices,
+    });
+  }
+
+  const results = await Promise.allSettled(
+    grantsToSchedule.map(async (grant) => {
+      await scheduleCreditGrantJobs(grant);
+      return grant.id;
+    })
+  );
+
+  const failed = results.filter((r) => r.status === 'rejected').length;
+  const succeeded = results.filter((r) => r.status === 'fulfilled').length;
+
+  if (failed > 0) {
+    logger.warn(`Failed to schedule jobs for ${failed} credit grants`);
+  }
+
+  logger.info('Credit grant queue started', {
+    totalGrants: grantsToSchedule.length,
+    succeeded,
+    failed,
+  });
+};
+
+creditGrantQueue.on('failed', ({ id, job, error }) => {
+  logger.error('Credit grant job failed', { id, job, error });
+});
+
+creditGrantQueue.on('finished', ({ id, job, result }) => {
+  logger.info('Credit grant job completed', { id, job, result });
+});
+
+async function handleInvoiceCredit(invoiceId: string) {
+  try {
+    const invoice = (await Invoice.findByPk(invoiceId, {
+      include: [
+        {
+          model: Customer,
+          as: 'customer',
+        },
+        {
+          model: InvoiceItem,
+          as: 'lines',
+        },
+      ],
+    })) as TInvoiceExpanded | null;
+
+    if (!invoice) {
+      logger.info('Invoice not found', { invoiceId });
+      return;
+    }
+
+    if (!invoice.customer) {
+      logger.warn('customer not found', { invoiceId });
+      return;
+    }
+
+    const lineItems = invoice.lines || [];
+
+    if (!Array.isArray(lineItems) || lineItems.length === 0) {
+      logger.info('No line items found in invoice', { invoiceId });
+      return;
+    }
+
+    const items = await Promise.all(
+      lineItems.map(async (lineItem) => {
+        const price = (await Price.findByPk(lineItem.price_id, {
+          include: [{ model: Product, as: 'product' }],
+        })) as TPriceExpanded | null;
+
+        if (!price) {
+          logger.warn('Price not found', { priceId: lineItem.price_id, invoiceId });
+          return null;
+        }
+
+        if (!price.product || price.product.type !== 'credit') {
+          return null;
+        }
+
+        const metadata = price.metadata || {};
+        const creditConfig = metadata.credit_config || {};
+        const quantity = lineItem.quantity || 1;
+        const creditAmount: BN = new BN(creditConfig.credit_amount ?? 1).mul(new BN(quantity));
+
+        const currency = await PaymentCurrency.findByPk(creditConfig.currency_id);
+
+        if (!currency) {
+          logger.error('Currency not found', { currencyId: creditConfig.currency_id, invoiceId });
+          throw new Error(`Currency not found: ${creditConfig.currency_id}`);
+        }
+
+        let applicabilityConfig: any = {
+          scope: {
+            type: 'metered',
+          },
+        };
+
+        let applicablePrices: string[] = [];
+        if (creditConfig.applicable_prices) {
+          applicablePrices = Array.isArray(creditConfig.applicable_prices)
+            ? creditConfig.applicable_prices
+            : creditConfig.applicable_prices.split(',');
+        }
+
+        if (applicablePrices.length > 0) {
+          applicabilityConfig = {
+            scope: {
+              prices: applicablePrices,
+            },
+          };
+        }
+        return {
+          price,
+          quantity,
+          metadata,
+          creditAmount,
+          applicablePrices,
+          expiredAt: calculateExpiresAt(
+            parseInt(String(creditConfig?.valid_duration_value || '0'), 10),
+            creditConfig?.valid_duration_unit || 'days'
+          ),
+          applicabilityConfig,
+          name: price.nickname || price.product.name,
+          currency: currency as TPaymentCurrency,
+        };
+      })
+    );
+
+    const validItems = items.filter((item): item is NonNullable<typeof item> => item !== null);
+
+    const processedMetadata = {
+      ...invoice.metadata,
+      credit_grant_processed: 'completed',
+      credit_grant_completed_at: dayjs().unix(),
+    };
+
+    if (validItems.length === 0) {
+      logger.info('No credit products found in invoice', { invoiceId });
+      return;
+    }
+
+    const existingGrants = await CreditGrant.findAll({
+      where: {
+        customer_id: invoice.customer.id,
+        metadata: {
+          invoice_id: invoice.id,
+        },
+      },
+    });
+
+    const existingPriceIds = new Set(existingGrants.map((grant) => grant.metadata?.price_id).filter(Boolean));
+    const grantsToCreate = validItems.filter((item) => !existingPriceIds.has(item.price.id));
+
+    if (grantsToCreate.length === 0) {
+      logger.info('All credit grants already exist for invoice', {
+        invoiceId,
+        totalItems: validItems.length,
+        existingCount: existingGrants.length,
+      });
+      // 标记为已完成
+      await Invoice.update(
+        {
+          metadata: processedMetadata,
+        },
+        { where: { id: invoiceId } }
+      );
+      return;
+    }
+
+    // 创建 Credit Grants
+    await Invoice.update(
+      {
+        metadata: {
+          ...invoice.metadata,
+          credit_grant_processed: 'processing',
+        },
+      },
+      { where: { id: invoiceId } }
+    );
+
+    try {
+      const createPromises = grantsToCreate.map(async (item) => {
+        const creditGrant = await createCreditGrant({
+          amount: fromTokenToUnit(item.creditAmount.toString(), item.currency.decimal).toString(),
+          currency_id: item.currency.id,
+          customer_id: invoice.customer.id,
+          name: item.price.nickname || item.price.product?.name,
+          category: 'paid',
+          priority: parseInt(String(item.metadata.credit_config?.priority || '50'), 10),
+          expires_at: item.expiredAt || undefined,
+          applicability_config: item.applicabilityConfig,
+          livemode: invoice.livemode,
+          created_via: 'invoice',
+          metadata: {
+            price_id: item.price.id,
+            invoice_id: invoice.id,
+            purchased_quantity: item.quantity,
+          },
+        });
+
+        logger.info('Credit Grant created from invoice', {
+          invoiceId,
+          customerId: invoice.customer.id,
+          productId: item.price.product_id,
+          priceId: item.price.id,
+          creditAmount: item.creditAmount.toString(),
+          expiresAt: item.expiredAt,
+          creditGrantId: creditGrant.id,
+        });
+
+        return creditGrant;
+      });
+      await Promise.all(createPromises);
+    } catch (error) {
+      logger.error('Failed to create Credit Grant from invoice', {
+        invoiceId,
+        error: error.message,
+        stack: error.stack,
+      });
+      await Invoice.update(
+        {
+          metadata: {
+            ...invoice.metadata,
+            credit_grant_processed: 'failed',
+          },
+        },
+        { where: { id: invoiceId } }
+      );
+      throw error;
+    }
+
+    // 所有创建成功，标记为已完成
+    await Invoice.update(
+      {
+        metadata: processedMetadata,
+      },
+      { where: { id: invoiceId } }
+    );
+
+    logger.info('All Credit Grants created successfully for invoice', {
+      invoiceId,
+      createdCount: grantsToCreate.length,
+      totalCreditItems: validItems.length,
+    });
+  } catch (error) {
+    logger.error('Failed to create Credit Grant from invoice', {
+      invoiceId,
+      error: error.message,
+      stack: error.stack,
+    });
+    throw error;
+  }
+}
+
+export async function addInvoiceCreditJob(invoiceId: string) {
+  const jobId = `invoice-credit-${invoiceId}`;
+
+  const existingJob = await creditGrantQueue.get(jobId);
+  if (existingJob) {
+    logger.info('Invoice credit job already exists, skipping duplicate', {
+      invoiceId,
+      jobId,
+    });
+  }
+
+  await creditGrantQueue.push({
+    id: jobId,
+    job: {
+      invoiceId,
+      action: 'create_from_invoice',
+    },
+    persist: true,
+  });
+
+  logger.info('Invoice credit job scheduled', {
+    invoiceId,
+    jobId,
+  });
+}
+
+events.on('invoice.paid', async (invoice: Invoice) => {
+  try {
+    await addInvoiceCreditJob(invoice.id);
+  } catch (error) {
+    logger.error('Failed to schedule credit grant job for invoice', {
+      invoiceId: invoice.id,
+      error: error.message,
+    });
+  }
+});
+
+events.on('customer.credit_grant.created', async (creditGrant: CreditGrant) => {
+  try {
+    await scheduleCreditGrantJobs(creditGrant);
+    logger.info('Credit grant jobs scheduled', {
+      creditGrantId: creditGrant.id,
+      customerId: creditGrant.customer_id,
+    });
+  } catch (error) {
+    logger.error('Failed to schedule credit grant jobs', {
+      creditGrantId: creditGrant.id,
+      error: error.message,
+    });
+  }
+});
+
+events.on('credit-grant.queued', async (id, job, args = {}) => {
+  const { sync, ...extraArgs } = args;
+  if (sync) {
+    try {
+      await creditGrantQueue.pushAndWait({
+        id,
+        job,
+        ...extraArgs,
+      });
+      events.emit('credit-grant.queued.done', { id });
+    } catch (error) {
+      logger.error('Error in credit-grant.queued', { id, job, error });
+      events.emit('credit-grant.queued.error', { id, job, error });
+    }
+    return;
+  }
+  try {
+    const existJob = await creditGrantQueue.get(id);
+    if (existJob) {
+      await creditGrantQueue.delete(id);
+      logger.info('Removed existing invoice job for immediate execution', {
+        id,
+        originalRunAt: existJob.runAt,
+      });
+    }
+    creditGrantQueue.push({
+      id,
+      job,
+      ...extraArgs,
+    });
+    events.emit('credit-grant.queued.done', { id });
+  } catch (error) {
+    logger.error('Error in credit-grant.queued', { id, job, error });
+    events.emit('credit-grant.queued.error', { id, job, error });
+  }
+});