@windrun-huaiin/backend-core 10.0.1

package/src/lib/stripe-config.ts

@@ -0,0 +1,333 @@
+import Stripe from 'stripe';
+import { Apilogger, userService, subscriptionService } from '../services/database/index';
+
+// Stripe Configuration
+export const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!, {
+  apiVersion: '2025-10-29.clover',
+});
+
+// Helper function to validate webhook signature
+export const validateStripeWebhook = (
+  payload: string | Buffer,
+  signature: string,
+  secret: string
+): Stripe.Event => {
+  return stripe.webhooks.constructEvent(payload, signature, secret);
+};
+
+export interface BasicCheckoutSessionParams {
+  priceId: string;
+  customerId?: string;
+  clientReferenceId: string; // user_id
+  successUrl: string;
+  cancelUrl: string;
+  metadata?: Record<string, string>;
+  // ✅ New: Auto-determine mode based on interval
+  interval?: string; // 'month' | 'year' | 'onetime' | undefined
+  // ✅ New: Subscription metadata for webhook processing
+  
+}
+
+// Helper function to create checkout session
+export const createCheckoutSession = async (
+  params: BasicCheckoutSessionParams,
+  subscriptionData?: Stripe.Checkout.SessionCreateParams.SubscriptionData
+): Promise<Stripe.Checkout.Session> => {
+  const {
+    priceId,
+    customerId,
+    clientReferenceId,
+    successUrl,
+    cancelUrl,
+    metadata,
+    interval
+  } = params;
+
+  // ✅ Dynamic mode determination: subscription if interval is not 'onetime'
+  const mode: 'subscription' | 'payment' = interval && interval !== 'onetime' ? 'subscription' : 'payment';
+  const isSubscriptionMode = mode === 'subscription';
+
+  if (isSubscriptionMode) {
+    if (!subscriptionData) { 
+      throw new Error('Subscription data is required for subscription mode');
+    }
+    const activeSubscription = await subscriptionService.getActiveSubscription(clientReferenceId);
+    if (activeSubscription) {
+      throw new ActiveSubscriptionExistsError();
+    }
+  }
+
+  const sessionParams: Stripe.Checkout.SessionCreateParams = {
+    mode, // ✅ Dynamic mode
+    payment_method_types: ['card'],
+    line_items: [
+      {
+        price: priceId,
+        quantity: 1,
+      },
+    ],
+    success_url: successUrl,
+    cancel_url: cancelUrl,
+    client_reference_id: clientReferenceId,
+    metadata: {
+      ...metadata,
+      mode, // Record mode for webhook processing
+    },
+  };
+
+  // Add customer if provided
+  if (customerId) {
+    sessionParams.customer = customerId;
+  }
+
+  // One-time payment specific configuration
+  if (isSubscriptionMode) {
+    // 在这里注入订单元数据，以保证后续事件处理能根据订单去匹配处理，只能在订阅模式里设置数据，否则Stripe报错
+    sessionParams.subscription_data = subscriptionData;
+  } else {
+    // One-time payments don't create invoices
+    sessionParams.invoice_creation = {
+      enabled: false, 
+    };
+  }
+
+  // Create log record with request
+  const logId = await Apilogger.logStripeOutgoing('createCheckoutSession', params);
+
+  try {
+    const session = await stripe.checkout.sessions.create(sessionParams);
+
+    // Update log record with response
+    Apilogger.updateResponse(logId, {
+      session_id: session.id,
+      url: session.url,
+      mode: session.mode
+    });
+
+    return session;
+  } catch (error) {
+    // Update log record with error
+    Apilogger.updateResponse(logId, {
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+    throw error;
+  }
+};
+
+// 根据发票ID去查支付ID
+export const fetchPaymentId = async (invoiceId: string ): Promise<string> => {
+  const fullInvoice = await stripe.invoices.retrieve(invoiceId, {
+    expand: ['payments']
+  });
+  const payment = fullInvoice.payments?.data[0];
+  const paymentIntentInfo = payment?.payment?.payment_intent;
+  const paymentIntentId = typeof paymentIntentInfo === 'string' ? paymentIntentInfo : (paymentIntentInfo as Stripe.PaymentIntent)?.id;
+  return paymentIntentId;
+}
+
+// Helper function to create or retrieve customer
+export const createOrGetCustomer = async (params: {
+  userId: string;
+}): Promise<string> => {
+  const { userId } = params;
+
+  const user = await userService.findByUserId(userId);
+
+  if (!user) {
+    throw new Error(`User not found for userId: ${userId}`);
+  }
+
+  const setStripeCustomerId = async (stripeCusId: string | null) => {
+    try {
+      await userService.updateStripeCustomerId(userId, stripeCusId);
+    } catch (error) {
+      console.error('Failed to update stripe customer id', { userId, stripeCusId, error });
+    }
+  };
+
+  if (user.stripeCusId) {
+    try {
+      const customer = await stripe.customers.retrieve(user.stripeCusId);
+      if ('deleted' in customer) {
+        await setStripeCustomerId(null);
+      } else {
+        return customer.id;
+      }
+    } catch (error) {
+      await setStripeCustomerId(null);
+      console.warn('Failed to retrieve Stripe customer, fallback to lookup by email', {
+        userId,
+        stripeCusId: user.stripeCusId,
+        error,
+      });
+    }
+  }
+
+  if (user.email) {
+    const existingCustomers = await stripe.customers.list({
+      email: user.email,
+      limit: 1,
+    });
+
+    if (existingCustomers.data.length > 0) {
+      const stripeCustomer = existingCustomers.data[0];
+      if (!user.stripeCusId || user.stripeCusId !== stripeCustomer.id) {
+        await setStripeCustomerId(stripeCustomer.id);
+      }
+      return stripeCustomer.id;
+    }
+  }
+
+  // 创建新客户
+  const customerParams: Stripe.CustomerCreateParams = {
+    metadata: {
+      user_id: userId,
+    },
+  };
+
+  if (user.email) {
+    customerParams.email = user.email;
+  }
+  const derivedName = user.email ? user.email.split('@')[0] : undefined;
+  if (derivedName) {
+    customerParams.name = derivedName;
+  }
+
+  // Create log record with request
+  const logId = await Apilogger.logStripeOutgoing('createCustomer', {
+    userId,
+    email: customerParams.email,
+    name: customerParams.name,
+  });
+  
+  try {
+    const customer = await stripe.customers.create(customerParams);
+    await setStripeCustomerId(customer.id);
+    
+    // Update log record with response
+    Apilogger.updateResponse(logId, {
+      customer_id: customer.id,
+      email: customer.email
+    });
+    
+    return customer.id;
+  } catch (error) {
+    // Update log record with error
+    Apilogger.updateResponse(logId, {
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+    throw error;
+  }
+};
+
+// Helper function to update subscription
+export const updateSubscription = async (params: {
+  subscriptionId: string;
+  priceId: string;
+  prorationBehavior?: 'create_prorations' | 'none' | 'always_invoice';
+}): Promise<Stripe.Subscription> => {
+  const { subscriptionId, priceId, prorationBehavior = 'create_prorations' } = params;
+
+  const subscription = await stripe.subscriptions.retrieve(subscriptionId);
+  
+  // Create log record with request
+  const logId = await Apilogger.logStripeOutgoing('updateSubscription', params);
+  
+  try {
+    const updatedSubscription = await stripe.subscriptions.update(subscriptionId, {
+      items: [
+        {
+          id: subscription.items.data[0].id,
+          price: priceId,
+        },
+      ],
+      proration_behavior: prorationBehavior,
+    });
+    
+    // Update log record with response
+    Apilogger.updateResponse(logId, {
+      subscription_id: updatedSubscription.id,
+      status: updatedSubscription.status
+    });
+    
+    return updatedSubscription;
+  } catch (error) {
+    // Update log record with error
+    Apilogger.updateResponse(logId, {
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+    throw error;
+  }
+};
+
+export const createCustomerPortalSession = async (params: {
+  customerId: string;
+  returnUrl: string;
+}): Promise<Stripe.BillingPortal.Session> => {
+  const logId = await Apilogger.logStripeOutgoing('createCustomerPortalSession', params);
+
+  try {
+    const session = await stripe.billingPortal.sessions.create({
+      customer: params.customerId,
+      return_url: params.returnUrl,
+    });
+
+    Apilogger.updateResponse(logId, {
+      session_id: session.id,
+      url: session.url,
+    });
+
+    return session;
+  } catch (error) {
+    Apilogger.updateResponse(logId, {
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+    throw error;
+  }
+};
+
+// Helper function to cancel subscription
+export const cancelSubscription = async (
+  subscriptionId: string,
+  cancelAtPeriodEnd: boolean = true
+): Promise<Stripe.Subscription> => {
+  // Create log record with request
+  const logId = await Apilogger.logStripeOutgoing('cancelSubscription', {
+    subscriptionId,
+    cancelAtPeriodEnd
+  });
+  
+  try {
+    let result: Stripe.Subscription;
+    
+    if (cancelAtPeriodEnd) {
+      result = await stripe.subscriptions.update(subscriptionId, {
+        cancel_at_period_end: true,
+      });
+    } else {
+      result = await stripe.subscriptions.cancel(subscriptionId);
+    }
+    
+    // Update log record with response
+    Apilogger.updateResponse(logId, {
+      subscription_id: result.id,
+      status: result.status,
+      cancel_at_period_end: result.cancel_at_period_end
+    });
+    
+    return result;
+  } catch (error) {
+    // Update log record with error
+    Apilogger.updateResponse(logId, {
+      error: error instanceof Error ? error.message : 'Unknown error'
+    });
+    throw error;
+  }
+};
+
+export class ActiveSubscriptionExistsError extends Error {
+  constructor() {
+    super('ACTIVE_SUBSCRIPTION_EXISTS');
+    this.name = 'ActiveSubscriptionExistsError';
+  }
+}

package/src/prisma/client.ts

@@ -0,0 +1,2 @@
+// Re-export generated Prisma client so consumers can import from "@windrun-huaiin/backend-core/prisma/client"
+export * from '@prisma/client';

package/src/prisma/index.ts

@@ -0,0 +1,3 @@
+export { prisma, checkAndFallbackWithNonTCClient } from './prisma';
+export { runInTransaction } from './prisma-transaction-util';
+export type { Prisma } from '@prisma/client';

package/src/prisma/prisma-transaction-util.ts

@@ -0,0 +1,24 @@
+import { prisma } from './prisma';
+import { Prisma } from '@prisma/client';
+
+// 事务工具类，回滚时打印回滚日志
+export async function runInTransaction<T>(
+  fn: (tx: Prisma.TransactionClient) => Promise<T>,
+  operationName?: string
+): Promise<T> {
+  const start = Date.now();
+  try {
+    return await prisma.$transaction(fn);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  } catch (error: any) {
+    const duration = Date.now() - start;
+    console.error('='.repeat(60));
+    console.error('TRANSACTION ROLLBACK');
+    console.error(`Operation: ${operationName || 'unknown'}`);
+    console.error(`Duration: ${duration}ms`);
+    console.error(`Error: ${error.message}`);
+    if (error.code) console.error(`Code: ${error.code}`);
+    console.error('='.repeat(60));
+    throw error;
+  }
+}

package/src/prisma/prisma.ts

@@ -0,0 +1,122 @@
+import { PrismaClient, Prisma } from '@prisma/client';
+
+const globalForPrisma = globalThis as unknown as {
+  prisma?: PrismaClient;
+  __prisma_query_logger_registered?: boolean;
+  __prisma_query_logger_id?: string;
+};
+
+// ==================== 日志配置 ====================
+const getLogConfig = () => {
+  const env = process.env.NODE_ENV || 'development';
+  switch (env) {
+    case 'development':
+      return [
+        { emit: 'event' as const, level: 'query' as const },
+        { emit: 'stdout' as const, level: 'info' as const },
+        { emit: 'stdout' as const, level: 'warn' as const },
+        { emit: 'stdout' as const, level: 'error' as const },
+      ];
+    case 'test':
+      return [
+        { emit: 'stdout' as const, level: 'warn' as const },
+        { emit: 'stdout' as const, level: 'error' as const },
+      ];
+    default:
+      return [{ emit: 'stdout' as const, level: 'error' as const }];
+  }
+};
+
+const logConfig = getLogConfig();
+
+// ==================== 创建 Prisma 全局单例 ====================
+export const prisma =
+  globalForPrisma.prisma ??
+  new PrismaClient<Prisma.PrismaClientOptions, 'query' | 'info' | 'warn' | 'error'>({
+    log: logConfig,
+  });
+
+if (process.env.NODE_ENV !== 'production') {
+  globalForPrisma.prisma = prisma;
+}
+
+if (process.env.NODE_ENV === 'development') {
+  const REGISTERED_KEY = '__prisma_query_logger_registered';
+  const ID_KEY = '__prisma_query_logger_id';
+
+  if (globalForPrisma[REGISTERED_KEY]) {
+    console.log(`Prisma Query Logger Already Registered | ID: ${globalForPrisma[ID_KEY]}`);
+  } else {
+    const listenerId = `listener_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
+    globalForPrisma[ID_KEY] = listenerId;
+
+    // --- 自定义SQL拼接 ---
+    const interpolate = (query: string, params: string) => {
+      // 1. 【核心修改】：安全检查和参数解析
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      let parameters: any[] = [];
+      try {
+        // 尝试解析 params 字符串
+        // 如果 params 是空字符串 ""，或者不是有效的 JSON，这里会捕获错误
+        parameters = params && params.length > 0 ? JSON.parse(params) : [];
+        // eslint-disable-next-line unused-imports/no-unused-vars
+      } catch (e) {
+        // 如果无法解析，则直接返回原始查询，跳过替换
+        return query; 
+      }
+      
+      // 确保 parameters 是一个数组
+      if (!Array.isArray(parameters)) {
+          console.warn('Prisma params解析结果不是数组，跳过参数替换。Result:', parameters);
+          return query;
+      }
+
+      // 如果没有参数，直接返回查询
+      if (parameters.length === 0) {
+        return query;
+      }
+
+      // 2. 将参数列表的值进行安全的字符串化处理
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const safeValues = parameters.map((p: any) => {
+        if (p === null) return 'NULL';
+        // 对字符串类型的值加上单引号并转义（这是SQL安全的关键）
+        if (typeof p === 'string') return `'${p.replace(/'/g, "''")}'`; 
+        return p; // 数字、布尔值等直接返回
+      });
+
+      // 3. 循环替换 $1, $2, ...
+      let sql = query;
+      for (let i = 0; i < safeValues.length; i++) {
+        const placeholder = new RegExp('\\$' + (i + 1) + '(?!\\d)', 'g');
+        sql = sql.replace(placeholder, safeValues[i]);
+      }
+      return sql;
+    };
+
+    const wrappedHandler = (event: Prisma.QueryEvent) => {
+      const ms = event.duration;
+      const slow = ms >= 200 ? '🐌 SLOW SQL ' : '🚀 SQL';
+
+      const interpolatedSql = interpolate(event.query, event.params);
+      
+      const clean = interpolatedSql
+        .replace(/"[^"]+"\./g, '')           // 去 "表".
+        .replace(/= '([^']+)'/g, `= '$1'`)   // 已经替换成单引号，此处可以优化
+        .replace(/"/g, '');                  // 彻底灭双引号
+
+      console.log('─'.repeat(60));
+      console.log(`${clean};`);
+      console.log(`⏰ 耗时: ${ms}ms, ${slow}`);
+    };
+    // 注册包装后的 handler
+    prisma.$on('query' as never, wrappedHandler);
+
+    globalForPrisma[REGISTERED_KEY] = true;
+  }
+}
+
+// ==================== 便捷方法, 入参事务客户端不存在或者不传, 就返回全局非事务客户端 ====================
+export function checkAndFallbackWithNonTCClient(tx?: Prisma.TransactionClient): Prisma.TransactionClient | PrismaClient {
+  return tx ?? prisma;
+}