payment-kit 1.20.11 → 1.20.12

package/api/src/queues/discount-status.ts

@@ -0,0 +1,200 @@
+import pAll from 'p-all';
+import createQueue from '../libs/queue';
+import { Coupon, PromotionCode } from '../store/models';
+import logger from '../libs/logger';
+import { events } from '../libs/event';
+import { validCoupon, validPromotionCode } from '../libs/discount/coupon';
+
+export type DiscountType = 'coupon' | 'promotion-code';
+
+export interface DiscountStatusJobData {
+  type: DiscountType;
+  id: string;
+}
+
+/**
+ * Process discount status check for both coupons and promotion codes
+ */
+export async function processDiscountStatus(job: DiscountStatusJobData) {
+  logger.info('Processing discount status check job', { job });
+  const { type, id } = job;
+
+  if (type === 'coupon') {
+    await processCouponStatus(id);
+  } else if (type === 'promotion-code') {
+    await processPromotionCodeStatus(id);
+  }
+}
+
+/**
+ * Process coupon status check
+ */
+async function processCouponStatus(couponId: string) {
+  const coupon = await Coupon.findByPk(couponId);
+  if (!coupon) {
+    return;
+  }
+
+  // Skip if already invalid
+  if (!coupon.valid) {
+    logger.info('Coupon is already invalid, skipping', { couponId });
+    return;
+  }
+
+  // Use the existing validCoupon function to check validity
+  const validation = validCoupon(coupon);
+
+  if (!validation.valid) {
+    // Mark coupon as invalid
+    await coupon.update({ valid: false, metadata: { ...coupon.metadata, invalid_reason: validation.reason } });
+    logger.info('Coupon marked as invalid', {
+      couponId,
+      reason: validation.reason,
+      redeem_by: coupon.redeem_by,
+      max_redemptions: coupon.max_redemptions,
+      times_redeemed: coupon.times_redeemed,
+    });
+    const promotionCodes = await PromotionCode.findAll({ where: { coupon_id: couponId, active: true } });
+    await pAll(
+      promotionCodes.map(
+        (promotionCode) => () =>
+          promotionCode.update({
+            active: false,
+            metadata: { ...promotionCode.metadata, invalid_reason: validation.reason },
+          })
+      ),
+      { concurrency: 5 }
+    );
+    logger.info('Promotion codes marked as inactive', {
+      promotionCodeIds: promotionCodes.map((pc) => pc.id),
+      reason: validation.reason,
+    });
+  }
+}
+
+/**
+ * Process promotion code status check
+ */
+async function processPromotionCodeStatus(promotionCodeId: string) {
+  const promotionCode = await PromotionCode.findByPk(promotionCodeId);
+  if (!promotionCode) {
+    logger.warn('Promotion code not found for status check', { promotionCodeId });
+    return;
+  }
+
+  // Skip if already inactive
+  if (!promotionCode.active) {
+    logger.info('Promotion code is already inactive, skipping', { promotionCodeId });
+    return;
+  }
+
+  // Use the existing validPromotionCode function to check validity
+  const validation = await validPromotionCode(promotionCode, {});
+
+  if (!validation.valid) {
+    // Mark promotion code as inactive
+    await promotionCode.update({
+      active: false,
+      metadata: { ...promotionCode.metadata, invalid_reason: validation.reason },
+    });
+    logger.info('Promotion code marked as inactive', {
+      promotionCodeId,
+      reason: validation.reason,
+      expires_at: promotionCode.expires_at,
+      max_redemptions: promotionCode.max_redemptions,
+      times_redeemed: promotionCode.times_redeemed,
+    });
+  }
+}
+
+/**
+ * Schedule discount status monitoring jobs
+ */
+export async function addDiscountStatusJob(
+  record: Coupon | PromotionCode,
+  type: DiscountType = 'coupon',
+  replace: boolean = false,
+  options: { delay?: number; runAt?: number } = {}
+) {
+  const { id } = record;
+  const jobId = `discount-status-${type}-${id}`;
+
+  // Remove existing job if present
+  const existingJob = await discountStatusQueue.get(jobId);
+  if (existingJob && !replace) {
+    logger.info('Discount job already exists, skipping', { type, id, jobId });
+    return;
+  }
+  if (existingJob && replace) {
+    await discountStatusQueue.delete(jobId);
+    logger.info('Removed existing discount status job for update', { type, id, jobId });
+  }
+  discountStatusQueue.push({ id: jobId, job: { type, id }, ...options });
+}
+
+// Create unified discount status queue
+export const discountStatusQueue = createQueue<DiscountStatusJobData>({
+  name: 'discount-status',
+  onJob: processDiscountStatus,
+  options: {
+    concurrency: 5,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+export const startDiscountStatusQueue = async () => {
+  logger.info('Starting discount status queue...');
+
+  const coupons = await Coupon.findAll({ where: { valid: true } });
+  const promotionCodes = await PromotionCode.findAll({ where: { active: true } });
+  await pAll(
+    coupons.map(
+      (coupon) => () =>
+        addDiscountStatusJob(coupon, 'coupon', false, {
+          runAt: coupon.redeem_by,
+        })
+    ),
+    { concurrency: 5 }
+  );
+  await pAll(
+    promotionCodes.map(
+      (promotionCode) => () =>
+        addDiscountStatusJob(promotionCode, 'promotion-code', false, {
+          runAt: promotionCode.expires_at,
+        })
+    ),
+    { concurrency: 5 }
+  );
+};
+
+events.on('coupon.created', (coupon: Coupon) => {
+  logger.info('Received coupon.created event', { couponId: coupon.id });
+  addDiscountStatusJob(coupon, 'coupon', true, {
+    runAt: coupon.redeem_by,
+  });
+});
+
+events.on('promotion-code.created', (promotionCode: PromotionCode) => {
+  addDiscountStatusJob(promotionCode, 'promotion-code', true, {
+    runAt: promotionCode.expires_at,
+  });
+});
+
+events.on('promotion-code.updated', (promotionCode: PromotionCode) => {
+  if (promotionCode.active) {
+    addDiscountStatusJob(promotionCode, 'promotion-code', true, {
+      runAt: promotionCode.expires_at,
+    });
+  }
+});
+
+events.on('discount-status.queued', (record, type, replace) => {
+  try {
+    addDiscountStatusJob(record, type, replace);
+    events.emit('discount-status.queued.done', record, type, replace);
+  } catch (error) {
+    logger.error('Error in discount-status.queued', { recordId: record.id, type, replace });
+    events.emit('discount-status.queued.error', record, type, replace);
+  }
+});

package/api/src/queues/subscription.ts

@@ -1,5 +1,6 @@
 import type { LiteralUnion } from 'type-fest';
 
+import { BN } from '@ocap/util';
 import { Op } from 'sequelize';
 import { createEvent } from '../libs/audit';
 import { ensurePassportRevoked } from '../integrations/blocklet/passport';
@@ -34,8 +35,10 @@ import { Invoice } from '../store/models/invoice';
 import { Price } from '../store/models/price';
 import { Subscription } from '../store/models/subscription';
 import { SubscriptionItem } from '../store/models/subscription-item';
+import { getValidDiscountsForSubscriptionBilling } from '../libs/discount/coupon';
 import { invoiceQueue } from './invoice';
 import { SubscriptionWillCanceledSchedule } from '../crons/subscription-will-canceled';
+import { applySubscriptionDiscount } from '../libs/discount/discount';
 
 type SubscriptionJob = {
   subscriptionId: string;
@@ -190,7 +193,90 @@ const doHandleSubscriptionInvoice = async ({
     return null;
   }
 
-  const amount = getSubscriptionCycleAmount(expandedItems, currency.id);
+  // Get valid discounts for this subscription billing period
+  const { validDiscounts, expiredDiscounts } = await getValidDiscountsForSubscriptionBilling({
+    subscriptionId: subscription.id,
+    customerId: subscription.customer_id,
+  });
+
+  logger.info('Valid discounts for subscription billing', {
+    subscriptionId: subscription.id,
+    validDiscounts: validDiscounts.map((d) => d.id),
+  });
+
+  // Log expired discounts for monitoring
+  if (expiredDiscounts.length > 0) {
+    logger.info('Found expired discounts during subscription billing', {
+      subscriptionId: subscription.id,
+      expiredDiscounts: expiredDiscounts.map((d) => d.id),
+    });
+  }
+
+  // Calculate subscription amount with discounts
+  const baseAmount = await getSubscriptionCycleAmount(expandedItems, currency.id);
+
+  // Apply discounts - simplified to use only one discount (first valid one)
+  const firstValidDiscount = validDiscounts?.[0] || null;
+  logger.info('First valid discount', {
+    subscriptionId: subscription.id,
+    firstValidDiscount: firstValidDiscount?.id,
+  });
+  let enhancedLineItems = expandedItems;
+  let discountSummary: {
+    appliedCoupon: string | null;
+    discountAmount: string;
+    totalDiscountAmount: string;
+    finalTotal: string;
+  } = {
+    appliedCoupon: null,
+    discountAmount: '0',
+    totalDiscountAmount: '0',
+    finalTotal: baseAmount.total,
+  };
+
+  if (firstValidDiscount) {
+    // Check if subscription is still in trial period for accurate discount calculation
+    const now = Math.floor(Date.now() / 1000);
+    const isTrialing = !!(subscription.trial_end && subscription.trial_end > now);
+
+    const discountApplication = await applySubscriptionDiscount({
+      lineItems: expandedItems,
+      discount: firstValidDiscount,
+      currency,
+      totalAmount: baseAmount.total,
+      billingContext: {
+        trialing: isTrialing,
+      },
+    });
+
+    logger.info('Discount application', {
+      subscriptionId: subscription.id,
+      discountApplication,
+    });
+
+    enhancedLineItems = discountApplication.enhancedLineItems;
+    discountSummary = discountApplication.discountSummary;
+  }
+
+  const { appliedCoupon, totalDiscountAmount, finalTotal } = discountSummary;
+
+  // Additional safety check to ensure final total is never negative
+  const safeFinalTotal = new BN(finalTotal || '0').lt(new BN('0')) ? '0' : finalTotal || '0';
+
+  // Prepare data for invoice creation
+  const appliedDiscounts = appliedCoupon && firstValidDiscount ? [firstValidDiscount.id] : [];
+  const discountBreakdownForInvoice =
+    appliedCoupon && firstValidDiscount ? [{ amount: totalDiscountAmount, discount: firstValidDiscount.id }] : [];
+
+  if (validDiscounts.length > 0) {
+    logger.info('Subscription billing discount calculation completed', {
+      subscriptionId: subscription.id,
+      originalTotal: baseAmount.total,
+      totalDiscount: totalDiscountAmount,
+      finalTotal,
+      appliedDiscounts: appliedDiscounts.length,
+    });
+  }
 
   const { invoice } = await ensureInvoiceAndItems({
     customer,
@@ -198,7 +284,7 @@ const doHandleSubscriptionInvoice = async ({
     subscription,
     trialing: false,
     metered: true,
-    lineItems: expandedItems,
+    lineItems: enhancedLineItems,
     props: {
       livemode: subscription.livemode,
       description: `Subscription ${reason}`,
@@ -209,11 +295,18 @@ const doHandleSubscriptionInvoice = async ({
       status,
       billing_reason: `subscription_${reason}`,
       currency_id: subscription.currency_id,
-      total: amount.total,
+      // Set correct subtotal (original amount) and total (after discount)
+      subtotal: baseAmount.total,
+      total: safeFinalTotal,
       payment_settings: subscription.payment_settings,
       default_payment_method_id: subscription.default_payment_method_id,
-      metadata,
-    } as Invoice,
+      // Discount information for Invoice
+      discounts: appliedDiscounts,
+      total_discount_amounts: discountBreakdownForInvoice,
+      metadata: {
+        ...metadata,
+      },
+    } as unknown as Invoice,
   });
 
   logger.info('Invoice created for subscription', { invoice: invoice.id, subscription: subscription.id });

package/api/src/queues/usage-record.ts

@@ -4,7 +4,7 @@ import dayjs from '../libs/dayjs';
 import { getLock } from '../libs/lock';
 import logger from '../libs/logger';
 import createQueue from '../libs/queue';
-import { getPriceUintAmountByCurrency } from '../libs/session';
+import { getPriceUintAmountByCurrency } from '../libs/price';
 import { Invoice, PaymentCurrency, Price, SubscriptionItem, TLineItemExpanded, UsageRecord } from '../store/models';
 import { Subscription } from '../store/models/subscription';
 import { invoiceQueue } from './invoice';

package/api/src/routes/auto-recharge-configs.ts

@@ -5,6 +5,7 @@ import { CustomError } from '@blocklet/error';
 import { Op } from 'sequelize';
 import sessionMiddleware from '@blocklet/sdk/lib/middlewares/session';
 import { BN, fromTokenToUnit, fromUnitToToken } from '@ocap/util';
+import { trimDecimals } from '../libs/math-utils';
 import {
   AutoRechargeConfig,
   Customer,
@@ -16,7 +17,8 @@ import {
   TPriceExpanded,
 } from '../store/models';
 import { isDelegationSufficientForPayment } from '../libs/payment';
-import { getPriceUintAmountByCurrency, validateStripePaymentAmounts } from '../libs/session';
+import { validateStripePaymentAmounts } from '../libs/session';
+import { getPriceUintAmountByCurrency } from '../libs/price';
 import { ensureStripeSetupIntentForAutoRecharge } from '../integrations/stripe/resource';
 import logger from '../libs/logger';
 
@@ -349,13 +351,13 @@ router.post('/submit', async (req, res) => {
   }
   let { threshold, daily_limits: dailyLimits } = configData;
   if (threshold) {
-    threshold = fromTokenToUnit(parseFloat(threshold).toFixed(currency.decimal), currency.decimal).toString();
+    threshold = fromTokenToUnit(trimDecimals(threshold, currency.decimal), currency.decimal).toString();
   }
   if (dailyLimits) {
     dailyLimits = {
       max_attempts: dailyLimits.max_attempts || 0,
       max_amount: fromTokenToUnit(
-        parseFloat(dailyLimits.max_amount || '0').toFixed(rechargeCurrency.decimal),
+        trimDecimals(dailyLimits.max_amount || '0', rechargeCurrency.decimal),
         rechargeCurrency.decimal
       ).toString(),
     };