Webhooks

export const webhookPayloadSchema = z.object({
  id: z.string().describe("Unique identifier for the event."),
  event: z
    .enum(WEBHOOK_TRIGGERS)
    .describe("The type of event that triggered the webhook."),
  createdAt: z
    .string()
    .describe("The date and time when the event was created in UTC."),
  data: z.any().describe("The data associated with the event."),
});

export const createWebhookSignature = async (secret: string, body: any) => {
  const keyData = new TextEncoder().encode(secret);
  const messageData = new TextEncoder().encode(JSON.stringify(body));

  const cryptoKey = await crypto.subtle.importKey(
    "raw",
    keyData,
    { name: "HMAC", hash: "SHA-256" },
    false,
    ["sign"],
  );

  const signature = await crypto.subtle.sign("HMAC", cryptoKey, messageData);
  const signatureArray = Array.from(new Uint8Array(signature));
  const hexSignature = signatureArray
    .map((byte) => byte.toString(16).padStart(2, "0"))
    .join("");

  return hexSignature;
};

export const WEBHOOK_FAILURE_NOTIFY_THRESHOLDS = [5, 10, 15] as const;
export const WEBHOOK_FAILURE_DISABLE_THRESHOLD = 20 as const;

import { webhookPayloadSchema } from "@dub/api";
import { createHmac } from "crypto";
import { NextResponse } from "next/server";

export async function POST(req: Request) {
  try {
    // Verify signature
    const signature = req.headers.get("X-Dub-Signature");
    const body = await req.text();
    
    const expectedSignature = createHmac("sha256", process.env.DUB_WEBHOOK_SECRET!)
      .update(body)
      .digest("hex");
    
    if (signature !== expectedSignature) {
      return NextResponse.json(
        { error: "Invalid signature" },
        { status: 401 }
      );
    }
    
    // Parse and validate payload
    const payload = webhookPayloadSchema.parse(JSON.parse(body));
    
    // Handle different event types
    switch (payload.event) {
      case "lead.created":
        await handleLeadCreated(payload.data);
        break;
      case "sale.created":
        await handleSaleCreated(payload.data);
        break;
      case "partner.enrolled":
        await handlePartnerEnrolled(payload.data);
        break;
      default:
        console.log(`Unhandled event: ${payload.event}`);
    }
    
    return NextResponse.json({ received: true });
  } catch (error) {
    console.error("Webhook error:", error);
    return NextResponse.json(
      { error: "Webhook processing failed" },
      { status: 500 }
    );
  }
}

async function handleLeadCreated(data: any) {
  // Send to CRM
  await fetch("https://your-crm.com/api/leads", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      email: data.customer.email,
      name: data.customer.name,
      source: data.link.shortLink,
      metadata: {
        click_id: data.click.id,
        country: data.click.country,
        device: data.click.device,
      },
    }),
  });
}

async function handleSaleCreated(data: any) {
  // Record revenue in analytics
  await fetch("https://your-analytics.com/api/revenue", {
    method: "POST",
    body: JSON.stringify({
      customer_id: data.customer.externalId,
      amount: data.sale.amount,
      currency: data.sale.currency,
      attributed_to: data.link.shortLink,
    }),
  });
}

async function handlePartnerEnrolled(data: any) {
  // Send welcome email to partner
  await sendEmail({
    to: data.email,
    subject: "Welcome to our Partner Program!",
    body: `Your unique link: ${data.links[0].shortLink}`,
  });
}