codeflash-internal/js/cf-api/endpoints/stripe-webhook.ts

import { Request, Response } from "express"
import { stripe } from "@codeflash-ai/common"
import { prisma } from "@codeflash-ai/common"
import * as Sentry from "@sentry/node"

// Define types for better type safety
type SubscriptionStatus = "active" | "past_due" | "canceled" | "incomplete"
type PlanType = "free" | "pro" | "enterprise"

interface SubscriptionData {
  user_id: string
  stripe_customer_id: string
  stripe_subscription_id: string
  plan_type: PlanType
  optimizations_limit: number
  subscription_status: SubscriptionStatus
  current_period_start: Date
  current_period_end: Date
}

export async function stripeWebhookHandler(req: Request, res: Response) {
  const sig = req.headers["stripe-signature"]

  try {
    const event = stripe.webhooks.constructEvent(req.body, sig!, process.env.STRIPE_WEBHOOK_SECRET!)

    console.log(`Processing Stripe webhook: ${event.type}`)

    // Extract useful data for debugging
    const eventObject = event.data.object
    console.log(`Event ID: ${event.id}`)

    // Handle different event types
    switch (event.type) {
      case "customer.subscription.created":
      case "customer.subscription.updated":
        await handleSubscriptionUpdate(eventObject)
        break

      case "customer.subscription.deleted":
        await handleSubscriptionCancellation(eventObject)
        break

      case "checkout.session.completed":
        await handleCheckoutCompleted(eventObject)
        break

      case "invoice.payment_failed":
        await handleFailedPayment(eventObject)
        break

      // We can acknowledge other events without processing them
      default:
        console.log(`No handler implemented for event type: ${event.type}`)
    }

    // Always return 200 to acknowledge receipt
    res.json({ received: true })
  } catch (err: any) {
    console.error("Webhook Error:", err.message)
    Sentry.captureException(err)
    return res.status(400).send(`Webhook Error: ${err.message}`)
  }
}

async function handleCheckoutCompleted(session: any) {
  // Extract userId from the session metadata
  const userId = session.metadata?.userId
  if (!userId) {
    console.error("No userId in checkout session metadata", session.id)
    return
  }

  console.log(`Processing checkout completion for user ${userId}`)

  // If this is a subscription checkout, fetch the subscription
  if (session.mode === "subscription" && session.subscription) {
    // Update the subscription with userId metadata if missing
    try {
      await stripe.subscriptions.update(session.subscription, {
        metadata: { userId },
      })

      // Also update customer metadata
      if (session.customer) {
        await stripe.customers.update(session.customer, {
          metadata: { userId },
        })
      }

      // Now fetch and process the subscription
      const subscription = await stripe.subscriptions.retrieve(session.subscription)
      await handleSubscriptionUpdate(subscription)
    } catch (error) {
      console.error("Error processing checkout session:", error)
      Sentry.captureException(error)
    }
  }
}

async function handleSubscriptionUpdate(subscription: any) {
  // First check subscription metadata
  let userId = subscription.metadata?.userId

  // If not in subscription metadata, check customer metadata
  if (!userId && subscription.customer) {
    try {
      const customer = await stripe.customers.retrieve(subscription.customer as string)
      if ("metadata" in customer) {
        userId = customer.metadata?.userId
      }
    } catch (error) {
      console.error("Error retrieving customer:", error)
    }
  }

  if (!userId) {
    console.error(
      "No userId found in subscription or customer metadata",
      JSON.stringify({
        subscription_id: subscription.id,
        customer_id: subscription.customer,
      }),
    )
    return
  }

  try {
    const priceId = subscription.items.data[0].price.id
    const price = await stripe.prices.retrieve(priceId)

    console.log(`Updating subscription for user ${userId}`)

    // Prepare update data
    const updateData: any = {
      stripe_subscription_id: subscription.id,
      plan_type: price.metadata?.tier || "pro",
      optimizations_limit: parseInt(price.metadata?.optimizations || "500"),
      subscription_status: subscription.status,
      current_period_start: new Date(subscription.current_period_start * 1000),
      current_period_end: new Date(subscription.current_period_end * 1000),
      updated_at: new Date(),
    }

    // Handle cancel_at_period_end if present in the subscription
    if (subscription.cancel_at_period_end !== undefined) {
      updateData.cancel_at_period_end = subscription.cancel_at_period_end

      // If subscription was just cancelled, record the cancellation date
      if (subscription.cancel_at_period_end === true && !subscription.cancellation_request_date) {
        updateData.cancellation_request_date = new Date()
      }
      // If subscription was reactivated, clear the cancellation date
      else if (subscription.cancel_at_period_end === false) {
        updateData.cancellation_request_date = null
      }
    }
    await prisma.subscriptions.upsert({
      where: { user_id: userId },
      create: {
        user_id: userId,
        stripe_customer_id: subscription.customer as string,
        stripe_subscription_id: subscription.id,
        plan_type: price.metadata?.tier || "pro",
        optimizations_limit: parseInt(price.metadata?.optimizations || "500"),
        optimizations_used: 0,
        subscription_status: subscription.status,
        current_period_start: new Date(subscription.current_period_start * 1000),
        current_period_end: new Date(subscription.current_period_end * 1000),
        created_at: new Date(),
        updated_at: new Date(),
        cancel_at_period_end: subscription.cancel_at_period_end || false,
        cancellation_request_date: subscription.cancel_at_period_end ? new Date() : null,
      },
      update: updateData,
    })

    console.log(`Successfully updated subscription for user ${userId}`)
  } catch (error) {
    console.error("Error updating subscription:", error)
    Sentry.captureException(error)
  }
}

async function handleSubscriptionCancellation(subscription: any) {
  const userId = subscription.metadata.userId
  if (!userId) return

  try {
    await prisma.subscriptions.update({
      where: { user_id: userId },
      data: {
        subscription_status: "canceled",
        plan_type: "free",
        optimizations_limit: 100,
        stripe_subscription_id: null,
        cancel_at_period_end: false, // The subscription is fully canceled, not pending cancellation
        cancellation_request_date: null,
      },
    })

    console.log(`Cancelled subscription for user ${userId}`)
  } catch (error) {
    console.error("Error cancelling subscription:", error)
    Sentry.captureException(error)
  }
}

async function handleFailedPayment(invoice: any) {
  if (!invoice.subscription) return

  try {
    const subscription = await stripe.subscriptions.retrieve(invoice.subscription)
    const userId = subscription.metadata.userId
    if (!userId) return

    await prisma.subscriptions.update({
      where: { user_id: userId },
      data: {
        subscription_status: "past_due",
      },
    })

    console.log(`Updated subscription status to past_due for user ${userId}`)
  } catch (error) {
    console.error("Error handling failed payment:", error)
    Sentry.captureException(error)
  }
}