Stripe、Paddle、Lemon Squeezy 怎么选：独立开发者收款方案对比

// 只调 Stripe Checkout，以为加税就完事了
async function createCheckoutSession(priceId: string, customerId: string) {
  // Stripe Tax 的 automatic_tax 只是在结账时向用户多收一笔税
  // 它不会替你向任何税务管辖区申报或缴纳
  const session = await stripe.checkout.sessions.create({
    customer: customerId,
    line_items: [{ price: priceId, quantity: 1 }],
    mode: 'subscription',
    automatic_tax: { enabled: true }, // ← 这只是计算，不是合规
    success_url: `${BASE_URL}/success`,
    cancel_url: `${BASE_URL}/pricing`,
  })
  // 问题：收到的税款停留在你的 Stripe 账户里
  // 你没有在任何国家做税务登记，也没有申报
  return session.url
}

// 方案 A：用 MoR（Paddle），税务全权委托
async function createPaddleSubscription(priceId: string, customerEmail: string) {
  // Paddle 作为 MoR，自动处理 VAT/GST/销售税的计算、申报和缴纳
  // 你收到的结算金额已经是扣除税款后的净收入
  const transaction = await paddle.transactions.create({
    items: [{ price: { id: priceId }, quantity: 1 }],
    customer: { email: customerEmail },
    // 不需要任何税务配置——Paddle 全权负责
  })
  return transaction
}
 
// 方案 B：用 PSP（Stripe），但搭配税务代理服务
async function createStripeSessionWithCompliance(priceId: string, customerId: string) {
  const session = await stripe.checkout.sessions.create({
    customer: customerId,
    line_items: [{ price: priceId, quantity: 1 }],
    mode: 'subscription',
    automatic_tax: { enabled: true },
    // 关键：你还需要自己完成以下步骤
    // 1. 在每个有税务义务的管辖区注册
    // 2. 按季度/月度申报
    // 3. 把代收的税款缴纳给对应税务局
    success_url: `${BASE_URL}/success`,
    cancel_url: `${BASE_URL}/pricing`,
  })
  return session.url
}

// app/api/webhooks/stripe/route.ts
export async function POST(req: Request) {
  const event = await stripe.webhooks.constructEvent(
    await req.text(),
    req.headers.get('stripe-signature')!,
    process.env.STRIPE_WEBHOOK_SECRET!
  )
 
  // 问题：没有检查事件是否已处理
  // 同一个事件可能被推送多次（网络重试、平台重发）
  switch (event.type) {
    case 'checkout.session.completed':
      // 每次收到都执行发货，重复事件 = 重复发货
      await activateSubscription(event.data.object.customer)
      break
    case 'customer.subscription.deleted':
      await revokeSubscription(event.data.object.customer)
      break
  }
  return new Response('ok')
}

export async function POST(req: Request) {
  const event = await stripe.webhooks.constructEvent(
    await req.text(),
    req.headers.get('stripe-signature')!,
    process.env.STRIPE_WEBHOOK_SECRET!
  )
 
  // 先查这个事件是否已经处理过
  const existing = await db.webhookEvents.findUnique({
    where: { eventId: event.id }  // event.id 是 Stripe 给的唯一标识
  })
  if (existing) {
    // 已处理过，直接返回 200，不重复执行
    return new Response('ok')
  }
 
  // 在事务中：记录事件 + 执行业务逻辑
  // 用数据库事务保证原子性，防止并发处理同一个事件
  await db.$transaction(async (tx) => {
    await tx.webhookEvents.create({
      data: { eventId: event.id, type: event.type, processedAt: new Date() }
    })
 
    switch (event.type) {
      case 'checkout.session.completed':
        await activateSubscription(tx, event.data.object.customer)
        break
      case 'customer.subscription.deleted':
        await revokeSubscription(tx, event.data.object.customer)
        break
      case 'invoice.payment_failed':
        await handlePaymentFailure(tx, event.data.object.customer)
        break
    }
  })
  return new Response('ok')
}

// 散落在各个业务模块中的支付调用
// 用户激活模块
async function onPaymentSuccess(lemonSqueezyWebhook: any) {
  const licenseKey = await lemonSqueezy.licenseKeys.get(
    lemonSqueezyWebhook.meta.custom_data.license_key_id
  )
  await db.users.update({
    where: { email: lemonSqueezyWebhook.meta.custom_data.email },
    data: {
      plan: 'pro',
      // 直接依赖 Lemon Squeezy 的许可证密钥结构
      licenseKey: licenseKey.data.attributes.serial_key,
      activatedAt: new Date(),
    }
  })
}
 
// 退款处理——也在不同文件
async function onRefund(lemonSqueezyWebhook: any) {
  const order = await lemonSqueezy.orders.get(
    lemonSqueezyWebhook.meta.order_id
  )
  await revokeAccess(order.data.attributes.user_email)
  // 还要处理许可证停用
  await lemonSqueezy.licenseKeys.deactivate(order.data.attributes.license_key_id)
}

// lib/payment/provider.ts — 统一支付接口
interface PaymentProvider {
  createCheckout(params: {
    priceId: string
    customerEmail: string
    metadata?: Record<string, string>
  }): Promise<{ checkoutUrl: string; sessionId: string }>
 
  handleWebhook(event: RawWebhookEvent): Promise<NormalizedPaymentEvent>
 
  // 统一退款接口——不同平台内部实现不同
  refund(params: {
    transactionId: string
    amount?: number
    reason?: string
  }): Promise<{ refundId: string; status: 'pending' | 'completed' }>
}
 
// lib/payment/normalized-event.ts — 统一事件模型
type NormalizedPaymentEvent =
  | { type: 'payment.success'; transactionId: string; customerId: string; amount: number }
  | { type: 'payment.refunded'; transactionId: string; customerId: string }
  | { type: 'subscription.activated'; customerId: string; planId: string; licenseKey?: string }
  | { type: 'subscription.cancelled'; customerId: string; endsAt: Date }
 
// lib/payment/paddle-provider.ts — Paddle 实现
class PaddleProvider implements PaymentProvider {
  async handleWebhook(event: RawWebhookEvent): Promise<NormalizedPaymentEvent> {
    // 把 Paddle 特有的事件结构转换成统一模型
    // 业务代码只需要处理 NormalizedPaymentEvent
    // ...
  }
}
 
// lib/payment/stripe-provider.ts — Stripe 实现
class StripeProvider implements PaymentProvider {
  async handleWebhook(event: RawWebhookEvent): Promise<NormalizedPaymentEvent> {
    // 把 Stripe 特有的事件结构转换成统一模型
    // ...
  }
}
 
// 业务代码——只依赖抽象，不依赖具体平台
async function onPaymentEvent(event: NormalizedPaymentEvent) {
  switch (event.type) {
    case 'subscription.activated':
      await db.users.update({
        where: { id: event.customerId },
        data: { plan: event.planId, licenseKey: event.licenseKey }
      })
      break
    case 'payment.refunded':
      await revokeAccess(event.customerId)
      break
  }
}