Webhooks

const created = await project.webhooks.create({
  url: "https://example.com/polymorfa/webhooks",
  eventTypes: ["message.received", "session.status"],
});

console.log(created.data.webhook.id);
const secret = created.data.secret; // Shown once. Store it now.

import { PolymorfaValidationError, WebhookSignatureError, webhooks } from "@polymorfa/sdk";

export default {
  async fetch(request: Request, env: { WEBHOOK_SECRET: string }): Promise<Response> {
    if (request.method !== "POST") return new Response(null, { status: 405 });

    const body = await request.arrayBuffer();
    try {
      const event = await webhooks.verify({
        body,
        signature: request.headers.get("x-webhook-signature") ?? "",
        secret: env.WEBHOOK_SECRET,
      });
      console.log(event.id, event.event);
      return Response.json({ received: event.id });
    } catch (error) {
      if (error instanceof WebhookSignatureError || error instanceof PolymorfaValidationError) {
        return new Response("Invalid webhook", { status: 400 });
      }
      throw error;
    }
  },
};

import { isEvent, type WebhookEvent } from "@polymorfa/sdk";

export function route(event: WebhookEvent) {
  if (isEvent(event, "message.received")) {
    console.log("message", event.session, event.payload);
  } else if (isEvent(event, "message.failed")) {
    console.log("failed", event.payload.error, event.payload.code);
  } else if (isEvent(event, "campaign.stopped")) {
    console.log("campaign stopped", event.payload.campaignId);
  } else {
    console.log("other event", event.event);
  }
}

const test = await project.webhooks.test(
  "<webhook-id>",
  { eventType: "message.received" },
  { idempotencyKey: crypto.randomUUID() },
);

console.log(test.data.eventId, test.data.deliveryId);

import { webhooks } from "@polymorfa/sdk";

const secret = "test-signing-secret";
const fixture = await webhooks.createFixture({
  event: {
    id: "evt_test_1",
    session: "number_test",
    timestamp: "2026-09-27T00:00:00Z",
    event: "session.status",
    payload: { status: "connected" },
  },
  secret,
});

// Send fixture.body with fixture.headers to your handler under test.
const event = await webhooks.verify({
  body: fixture.body,
  signature: fixture.headers["x-webhook-signature"],
  secret,
});
console.log(event.event); // "session.status"

const rotated = await project.webhooks.rotateSecret("<webhook-id>", {
  overlapSeconds: 3600,
});

const newSecret = rotated.data.secret;
console.log(rotated.data.secretMetadata.previousValidUntil);

for await (const delivery of await project.webhookDeliveries.list({ status: "failed" })) {
  console.log(delivery.id, delivery.eventId, delivery.lastOutcome?.statusCode);

  if (delivery.capabilities.retryable) {
    await project.webhookDeliveries.retry(delivery.id);
  }
}