How to Send Email with Bun

AHASEND_API_KEY=aha-sk-...
AHASEND_ACCOUNT_ID=your-account-uuid
AHASEND_WEBHOOK_SECRET=aha-whsec-...
WELCOME_ENDPOINT_TOKEN=replace-with-a-long-random-value

import { AhaSendClient } from "@ahasend/sdk";

export const ahasend = new AhaSendClient({
  apiKey: process.env.AHASEND_API_KEY!,
  accountId: process.env.AHASEND_ACCOUNT_ID!,
});

import { createHash, timingSafeEqual } from "node:crypto";
import { AhaSendAPIError } from "@ahasend/sdk";
import { ahasend } from "./lib/ahasend";

const welcomeEndpointToken = process.env.WELCOME_ENDPOINT_TOKEN;
if (!welcomeEndpointToken) throw new Error("WELCOME_ENDPOINT_TOKEN is required");
const expectedTokenHash = createHash("sha256").update(welcomeEndpointToken).digest();

function isAuthorized(header: string | null): boolean {
  const provided = header?.startsWith("Bearer ") ? header.slice(7) : "";
  if (!provided) return false;
  return timingSafeEqual(createHash("sha256").update(provided).digest(), expectedTokenHash);
}

Bun.serve({
  port: 3000,
  maxRequestBodySize: 30_000_000,
  development: false,
  error(err) {
    console.error("Unhandled server error", { name: err.name });
    return new Response("Internal Server Error", { status: 500 });
  },
  async fetch(req) {
    const url = new URL(req.url);

    if (req.method === "POST" && url.pathname === "/api/welcome") {
      if (!isAuthorized(req.headers.get("authorization"))) {
        return Response.json({ error: "Unauthorized" }, { status: 401 });
      }

      const body = (await req.json().catch(() => null)) as {
        email?: unknown;
        name?: unknown;
      } | null;
      const { email, name } = body ?? {};
      if (typeof email !== "string" || !email.includes("@")) {
        return Response.json({ error: "A valid `email` is required" }, { status: 400 });
      }
      if (name !== undefined && typeof name !== "string") {
        return Response.json({ error: "`name` must be a string" }, { status: 400 });
      }

      try {
        const result = await ahasend.messages.send({
          from: { email: "hello@yourdomain.com", name: "Your App" },
          recipients: [{ email, name }],
          subject: "Welcome to Your App!",
          html_content: "<h1>Welcome aboard 🎉</h1><p>We're glad you're here.</p>",
          text_content: "Welcome aboard! We're glad you're here.",
        });

        const rejected = result.data.filter((r) => r.status === "error");
        if (rejected.length > 0) console.warn(`${rejected.length} recipient(s) rejected`);

        return Response.json({ statuses: result.data.map((r) => r.status) }); // ["queued"]
      } catch (err) {
        if (err instanceof AhaSendAPIError) {
          console.error("AhaSend request failed", {
            status: err.status,
            requestId: err.requestId,
          });
          return Response.json({ error: "Failed to send email" }, { status: 502 });
        }
        throw err;
      }
    }

    return new Response("Not found", { status: 404 });
  },
});

import {
  AhaSendWebhookVerificationError,
  WebhookVerifier,
  isKnownWebhookEvent,
} from "@ahasend/sdk/webhooks";

const verifier = new WebhookVerifier(process.env.AHASEND_WEBHOOK_SECRET!);

// inside the fetch handler, above the 404 fallback:
if (req.method === "POST" && url.pathname === "/webhooks/ahasend") {
  let event;
  try {
    const rawBody = new Uint8Array(await req.arrayBuffer());
    event = await verifier.parse(req.headers, rawBody);
  } catch (err) {
    if (err instanceof AhaSendWebhookVerificationError) {
      return new Response("Invalid signature", { status: 400 });
    }
    throw err;
  }

  if (isKnownWebhookEvent(event)) {
    switch (event.type) {
      case "message.delivered":
        console.log("Message delivered");
        break;
      case "message.bounced":
        console.log("Message bounced");
        break;
      case "message.opened":
        console.log("Message opened");
        break;
    }
  }

  return new Response(null, { status: 200 });
}