pleskSaas/app/api/stripe/webhook/route.ts

import { NextResponse } from "next/server";
import type Stripe from "stripe";

import { env } from "@/lib/env";
import { getStripeClient } from "@/lib/stripe";
import { createSupabaseAdminClient } from "@/lib/supabase/admin";

function toIsoOrNull(unixSeconds?: number | null) {
  if (!unixSeconds) return null;
  return new Date(unixSeconds * 1000).toISOString();
}

async function upsertBillingByCustomer(
  customerId: string,
  updates: {
    stripe_subscription_id?: string | null;
    plan_id?: string | null;
    subscription_status?: string | null;
    current_period_end?: string | null;
  },
) {
  const supabase = createSupabaseAdminClient() as any;

  const { data: existing } = await supabase
    .from("billing_accounts")
    .select("id")
    .eq("stripe_customer_id", customerId)
    .maybeSingle();

  if (existing?.id) {
    await supabase
      .from("billing_accounts")
      .update(updates)
      .eq("id", existing.id);
  }
}

async function handleCheckoutSessionCompleted(
  session: Stripe.Checkout.Session,
) {
  const agencyId =
    typeof session.metadata?.agency_id === "string"
      ? session.metadata.agency_id
      : null;
  const customerId =
    typeof session.customer === "string" ? session.customer : null;

  if (!agencyId || !customerId) return;

  const supabase = createSupabaseAdminClient() as any;
  const payload = {
    agency_id: agencyId,
    stripe_customer_id: customerId,
    stripe_subscription_id:
      typeof session.subscription === "string"
        ? (session.subscription as string)
        : null,
    subscription_status: "active",
  };

  const { data: existing } = await supabase
    .from("billing_accounts")
    .select("id")
    .eq("agency_id", agencyId)
    .maybeSingle();

  if (existing?.id) {
    await supabase
      .from("billing_accounts")
      .update(payload)
      .eq("id", existing.id);
  } else {
    await supabase.from("billing_accounts").insert(payload);
  }
}

async function handleSubscriptionUpdated(subscription: Stripe.Subscription) {
  const customerId =
    typeof subscription.customer === "string"
      ? subscription.customer
      : subscription.customer?.id;
  const currentPeriodEnd =
    "current_period_end" in subscription
      ? (subscription as { current_period_end?: number | null })
          .current_period_end
      : null;

  if (!customerId) return;

  await upsertBillingByCustomer(customerId, {
    stripe_subscription_id: subscription.id,
    plan_id: subscription.items.data[0]?.price.id ?? null,
    subscription_status: subscription.status,
    current_period_end: toIsoOrNull(currentPeriodEnd),
  });
}

async function handleSubscriptionDeleted(subscription: Stripe.Subscription) {
  const customerId =
    typeof subscription.customer === "string"
      ? subscription.customer
      : subscription.customer?.id;
  const currentPeriodEnd =
    "current_period_end" in subscription
      ? (subscription as { current_period_end?: number | null })
          .current_period_end
      : null;

  if (!customerId) return;

  await upsertBillingByCustomer(customerId, {
    stripe_subscription_id: subscription.id,
    subscription_status: "canceled",
    current_period_end: toIsoOrNull(currentPeriodEnd),
  });
}

export async function POST(req: Request) {
  try {
    if (!env.stripeWebhookSecret) {
      throw new Error("STRIPE_WEBHOOK_SECRET is not configured");
    }

    const signature = req.headers.get("stripe-signature");
    if (!signature) {
      return NextResponse.json(
        { error: "Missing stripe-signature header" },
        { status: 400 },
      );
    }

    const stripe = getStripeClient();
    const body = await req.text();
    const event = stripe.webhooks.constructEvent(
      body,
      signature,
      env.stripeWebhookSecret,
    );

    switch (event.type) {
      case "checkout.session.completed":
        await handleCheckoutSessionCompleted(
          event.data.object as Stripe.Checkout.Session,
        );
        break;
      case "customer.subscription.updated":
        await handleSubscriptionUpdated(
          event.data.object as Stripe.Subscription,
        );
        break;
      case "customer.subscription.deleted":
        await handleSubscriptionDeleted(
          event.data.object as Stripe.Subscription,
        );
        break;
      default:
        break;
    }

    return NextResponse.json({ received: true });
  } catch (error) {
    return NextResponse.json(
      {
        error:
          error instanceof Error ? error.message : "Webhook handling failed",
      },
      { status: 400 },
    );
  }
}