How to Send Email with ElysiaJS (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 { Elysia, t } from "elysia";
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) {
  const provided = header?.startsWith("Bearer ") ? header.slice(7) : "";
  return provided !== "" && timingSafeEqual(createHash("sha256").update(provided).digest(), expectedTokenHash);
}

const WELCOME_PATH = "/api/welcome";

const app = new Elysia({
  serve: { maxRequestBodySize: 30_000_000 },
})
  .onRequest(({ request, set }) => {
    if (new URL(request.url).pathname !== WELCOME_PATH) return;
    if (!isAuthorized(request.headers.get("authorization"))) {
      set.status = 401;
      return { error: "Unauthorized" };
    }
  })
  .onError(({ code, error, set }) => {
    if (code === "VALIDATION" || code === "PARSE" || code === "NOT_FOUND") return;
    console.error("Unhandled server error", {
      code,
      name: error instanceof Error ? error.name : "unknown",
    });
    set.status = 500;
    return { error: "Internal Server Error" };
  })
  .post(
    WELCOME_PATH,
    async ({ body, set }) => {
      try {
        const result = await ahasend.messages.send({
          from: { email: "hello@yourdomain.com", name: "Your App" },
          recipients: [{ email: body.email, name: body.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-${body.eventId}` });

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

        set.status = rejected.length ? 422 : 202;
        return { statuses: result.data.map((r) => r.status) }; // ["queued"]
      } catch (err) {
        if (err instanceof AhaSendAPIError) {
          console.error(`AhaSend error ${err.status} (request ${err.requestId})`);
          set.status = 502;
          return { error: "Failed to send email" };
        }
        throw err;
      }
    },
    {
      body: t.Object({
        email: t.String({ format: "email" }),
        name: t.Optional(t.String()),
        eventId: t.String({ pattern: "^[A-Za-z0-9._:-]{1,200}$" }),
      }),
    },
  );

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

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

async function readRawBody(request: Request): Promise<Uint8Array | null> {
  const reader = request.body?.getReader();
  if (!reader) return new Uint8Array();

  const chunks: Uint8Array[] = [];
  let length = 0;
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    length += value.byteLength;
    if (length > MAX_WEBHOOK_BODY_BYTES) {
      await reader.cancel();
      return null;
    }
    chunks.push(value);
  }

  const body = new Uint8Array(length);
  let offset = 0;
  for (const chunk of chunks) {
    body.set(chunk, offset);
    offset += chunk.byteLength;
  }
  return body;
}

app
  .post(
    "/webhooks/ahasend",
    async ({ request, set }) => {
      const rawBody = await readRawBody(request);
      if (rawBody === null) {
        set.status = 413;
        return;
      }

      let event;
      try {
        event = await verifier.parse(request.headers, rawBody);
      } catch (err) {
        if (err instanceof AhaSendWebhookVerificationError) {
          set.status = 400;
          return;
        }
        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;
        }
      }

      set.status = 200;
    },
    { parse: "none" },
  )
  .listen(3000);