payment-kit 1.20.11 → 1.20.13

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/queues/vendors/fulfillment-coordinator.ts

@@ -13,35 +13,7 @@ import { Refund } from '../../store/models/refund';
 import { sequelize } from '../../store/sequelize';
 import { depositVaultQueue } from '../payment';
 
-type VendorInfo = {
-  vendor_id: string;
-  vendor_key: string;
-  order_id: string;
-  status:
-    | 'pending'
-    | 'processing'
-    | 'completed'
-    | 'failed'
-    | 'cancelled'
-    | 'max_retries_exceeded'
-    | 'return_requested'
-    | 'sent';
-  service_url?: string;
-  error_message?: string;
-  amount: string;
-
-  attempts?: number;
-  lastAttemptAt?: string;
-  completedAt?: string;
-  commissionAmount?: string;
-
-  returnRequest?: {
-    reason: string;
-    requestedAt: string;
-    status: 'pending' | 'accepted' | 'rejected';
-    returnDetails?: string;
-  };
-};
+export type VendorInfo = NonNullable<CheckoutSession['vendor_info']>[number];
 
 interface CoordinatorJob {
   checkoutSessionId: string;

package/api/src/queues/vendors/return-processor.ts

@@ -0,0 +1,184 @@
+import logger from '../../libs/logger';
+import createQueue from '../../libs/queue';
+import { VendorFulfillmentService } from '../../libs/vendor-util/fulfillment';
+import { CheckoutSession } from '../../store/models';
+import { VendorInfo } from './fulfillment-coordinator';
+
+type ReturnProcessorJob = {
+  checkoutSessionId: string;
+};
+
+export const vendorReturnProcessorQueue = createQueue<ReturnProcessorJob>({
+  name: 'vendor-return-processor',
+  onJob: handleReturnProcessorJob,
+  options: {
+    concurrency: 1,
+    maxRetries: 2,
+    retryDelay: 30 * 1000,
+  },
+});
+
+async function handleReturnProcessorJob(job: ReturnProcessorJob): Promise<void> {
+  const { checkoutSessionId } = job;
+
+  logger.info('Starting vendor return processor job', {
+    checkoutSessionId,
+  });
+
+  try {
+    const checkoutSession = await CheckoutSession.findByPk(checkoutSessionId);
+
+    if (!checkoutSession) {
+      logger.warn('CheckoutSession not found', { checkoutSessionId });
+      return;
+    }
+
+    const vendorInfoList = checkoutSession.vendor_info as VendorInfo[];
+    let hasChanges = false;
+
+    let i = -1;
+    for (const vendor of vendorInfoList) {
+      i++;
+      // Only process vendors with 'completed' status
+      if (vendor.status !== 'completed') {
+        logger.info('Skipping vendor return because status is not completed', {
+          checkoutSessionId,
+          vendorId: vendor.vendor_id,
+          orderId: vendor.order_id,
+          status: vendor.status,
+        });
+        // eslint-disable-next-line no-continue
+        continue;
+      }
+
+      try {
+        logger.info('Processing vendor return', {
+          checkoutSessionId,
+          vendorId: vendor.vendor_id,
+          orderId: vendor.order_id,
+        });
+
+        // eslint-disable-next-line no-await-in-loop
+        const returnResult = await callVendorReturn(vendor, checkoutSession);
+
+        if (returnResult.success) {
+          // Return successful, update status to 'returned'
+          vendorInfoList[i] = {
+            ...vendor,
+            status: 'returned',
+            lastAttemptAt: new Date().toISOString(),
+          };
+          hasChanges = true;
+
+          logger.info('Vendor return successful', {
+            checkoutSessionId,
+            vendorId: vendor.vendor_id,
+            orderId: vendor.order_id,
+          });
+        } else {
+          // Return failed, keep 'completed' status for next scan retry
+          vendorInfoList[i] = {
+            ...vendor,
+            lastAttemptAt: new Date().toISOString(),
+            error_message: returnResult.message || 'Return request failed',
+          };
+
+          logger.warn('Vendor return failed', {
+            checkoutSessionId,
+            vendorId: vendor.vendor_id,
+            orderId: vendor.order_id,
+            error: returnResult.message,
+          });
+        }
+      } catch (error: any) {
+        logger.error('Error processing vendor return', {
+          checkoutSessionId,
+          vendorId: vendor.vendor_id,
+          orderId: vendor.order_id,
+          error: error.message,
+        });
+
+        // Record error but keep status unchanged for retry
+        vendorInfoList[i] = {
+          ...vendor,
+          lastAttemptAt: new Date().toISOString(),
+          error_message: error.message,
+        };
+        hasChanges = true;
+      }
+    }
+
+    // Update vendor_info if there are changes
+    if (hasChanges) {
+      await checkoutSession.update({ vendor_info: vendorInfoList });
+    }
+
+    // Check if all vendors have been returned
+    const allReturned = vendorInfoList.every((vendor) => vendor.status === 'returned');
+
+    if (allReturned && checkoutSession.fulfillment_status !== 'returned') {
+      await checkoutSession.update({ fulfillment_status: 'returned' });
+
+      logger.info('All vendors returned, updated fulfillment status to returned', {
+        checkoutSessionId,
+        totalVendors: vendorInfoList.length,
+      });
+    }
+
+    logger.info('Vendor return processor job completed', {
+      checkoutSessionId,
+      totalVendors: vendorInfoList.length,
+      allReturned,
+      hasChanges,
+    });
+  } catch (error: any) {
+    logger.error('Vendor return processor job failed', {
+      checkoutSessionId,
+      error,
+    });
+    throw error;
+  }
+}
+
+async function callVendorReturn(
+  vendor: VendorInfo,
+  checkoutSession: CheckoutSession
+): Promise<{ success: boolean; message?: string }> {
+  try {
+    const vendorAdapter = await VendorFulfillmentService.getVendorAdapter(vendor.vendor_key);
+
+    if (!vendorAdapter) {
+      return {
+        success: false,
+        message: `No adapter found for vendor: ${vendor.vendor_id}`,
+      };
+    }
+
+    const returnResult = await vendorAdapter.requestReturn({
+      orderId: vendor.order_id,
+      reason: 'Subscription canceled',
+      paymentIntentId: checkoutSession.payment_intent_id || '',
+      customParams: {
+        checkoutSessionId: checkoutSession.id,
+        subscriptionId: checkoutSession.subscription_id,
+        vendorKey: vendor.vendor_key,
+      },
+    });
+
+    return {
+      success: returnResult.success || false,
+      message: returnResult.message,
+    };
+  } catch (error: any) {
+    logger.error('Failed to call vendor return API', {
+      vendorId: vendor.vendor_id,
+      orderId: vendor.order_id,
+      error: error.message,
+    });
+
+    return {
+      success: false,
+      message: error.message,
+    };
+  }
+}

package/api/src/queues/vendors/return-scanner.ts

@@ -0,0 +1,119 @@
+import { Op } from 'sequelize';
+import logger from '../../libs/logger';
+import createQueue from '../../libs/queue';
+import { CheckoutSession, Subscription } from '../../store/models';
+import { vendorReturnProcessorQueue } from './return-processor';
+import { VendorInfo } from './fulfillment-coordinator';
+
+export const vendorReturnScannerQueue = createQueue({
+  name: 'vendor-return-scanner',
+  onJob: handleReturnScannerJob,
+  options: {
+    concurrency: 1,
+    maxRetries: 3,
+    retryDelay: 60 * 1000,
+  },
+});
+
+async function handleReturnScannerJob(): Promise<void> {
+  try {
+    const sessionsNeedingReturn = await findSessionsNeedingVendorReturn();
+    if (sessionsNeedingReturn.length === 0) {
+      logger.info('No checkout sessions needing vendor return');
+      return;
+    }
+
+    logger.info('Found checkout sessions needing vendor return', {
+      count: sessionsNeedingReturn.length,
+      sessionIds: sessionsNeedingReturn.map((s) => s.id),
+    });
+
+    for (const session of sessionsNeedingReturn) {
+      const id = `vendor-return-process-${session.id}`;
+      // eslint-disable-next-line no-await-in-loop
+      const exists = await vendorReturnProcessorQueue.get(id);
+      if (!exists) {
+        vendorReturnProcessorQueue.push({
+          id,
+          job: {
+            checkoutSessionId: session.id,
+          },
+        });
+      }
+    }
+  } catch (error: any) {
+    logger.error('Vendor return scanner job failed', {
+      error,
+    });
+    throw error;
+  }
+}
+
+async function findSessionsNeedingVendorReturn(): Promise<CheckoutSession[]> {
+  try {
+    // First, find canceled subscriptions
+    const canceledSubscriptions = await Subscription.findAll({
+      where: { status: 'canceled' },
+      attributes: ['id'],
+    });
+
+    const canceledSubscriptionIds = canceledSubscriptions.map((sub) => sub.id);
+
+    // Find checkout sessions with completed fulfillment and canceled subscriptions
+    const readyToReturnSessions = await CheckoutSession.findAll({
+      where: {
+        fulfillment_status: 'completed',
+        subscription_id: { [Op.in]: canceledSubscriptionIds },
+      },
+      order: [['updated_at', 'DESC']],
+      limit: 100,
+    });
+
+    // Find checkout sessions already in returning status
+    const returningSessions = await CheckoutSession.findAll({
+      where: {
+        fulfillment_status: 'returning',
+        subscription_id: { [Op.ne]: null as any },
+      },
+      order: [['updated_at', 'DESC']],
+      limit: 100,
+    });
+
+    // Update canceled sessions to returning status
+    if (readyToReturnSessions.length > 0) {
+      await CheckoutSession.update(
+        {
+          fulfillment_status: 'returning',
+        },
+        {
+          where: {
+            id: { [Op.in]: readyToReturnSessions.map((s) => s.id) },
+          },
+        }
+      );
+    }
+
+    const sessions = [...readyToReturnSessions, ...returningSessions];
+
+    // Filter sessions that have vendors needing return
+    const filteredSessions = sessions.filter((session) => {
+      const vendorInfoList = session.vendor_info as VendorInfo[];
+
+      if (!vendorInfoList || vendorInfoList.length === 0) {
+        return false;
+      }
+      const hasVendorNeedingReturn = vendorInfoList.some((vendor) => vendor.status === 'completed');
+      return hasVendorNeedingReturn;
+    });
+
+    return filteredSessions;
+  } catch (error: any) {
+    logger.error('Failed to find sessions needing vendor return', { error });
+    throw error;
+  }
+}
+
+export function scheduleVendorReturnScan(): void {
+  const scanId = `scan-${Date.now()}`;
+  vendorReturnScannerQueue.push({ id: scanId, job: {} });
+}

package/api/src/queues/vendors/status-check.ts

@@ -1,5 +1,5 @@
 import { joinURL } from 'ufo';
-import { VendorAuth } from '@blocklet/payment-vendor';
+import { Auth as VendorAuth } from '@blocklet/payment-vendor';
 import createQueue from '../../libs/queue';
 import { CheckoutSession } from '../../store/models/checkout-session';
 import { ProductVendor } from '../../store/models';