How to Send Email with Bun

import { AhaSendClient } from "@ahasend/sdk";
try {
  const client = AhaSendClient.fromEnv();
  const result = await client.messages.send({
    from: { email: process.env.AHASEND_FROM },
    recipients: [{ email: "recipient@example.com" }],
    subject: "My first sandbox email",
    text_content: "Hello from AhaSend",
    sandbox: true,
  });
  const statuses = result.data.map((entry) => entry.status);
  console.log({ statuses });
  if (!statuses.length || statuses.some((s) => !["queued", "scheduled"].includes(s)))
    throw new Error("A recipient was rejected");
} catch {
  console.error("Sandbox send failed; check your credentials, sender and account.");
  process.exitCode = 1;
}

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";

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

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


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;
        eventId?: unknown;
      } | null;
      const { email, name, eventId } = body ?? {};
      if (typeof eventId !== "string" || !/^[A-Za-z0-9._:-]{1,200}$/.test(eventId)) {
        return Response.json({ error: "A valid eventId is required" }, { status: 400 });
      }
      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.",
          sandbox: true,
        }, { idempotencyKey: `sandbox-welcome-${eventId}` });

        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) }, { status: rejected.length ? 422 : 202 }); // ["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;
      }
    }

    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 });
    }

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