How to Send Email with Hono

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_ROUTE_TOKEN=replace-with-a-long-random-token

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

export function requireEnv(name: string): string {
  const value = process.env[name];
  if (!value) throw new Error(`Missing required environment variable: ${name}`);
  return value;
}

export const ahasend = new AhaSendClient({
  apiKey: requireEnv("AHASEND_API_KEY"),
  accountId: requireEnv("AHASEND_ACCOUNT_ID"),
});

import { Hono } from "hono";
import { serve } from "@hono/node-server";
import { bearerAuth } from "hono/bearer-auth";
import { bodyLimit } from "hono/body-limit";
import { AhaSendAPIError } from "@ahasend/sdk";
import { ahasend, requireEnv } from "./lib/ahasend.js";

const app = new Hono();

app.use(
  "/api/*",
  bearerAuth({ token: requireEnv("WELCOME_ROUTE_TOKEN") }),
);

type WelcomeInput = {
  email: string;
  name?: string;
  eventId: string;
};

function isWelcomeInput(value: unknown): value is WelcomeInput {
  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
  const input = value as Record<string, unknown>;
  return (
    typeof input.email === "string" &&
    input.email.length <= 254 &&
    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input.email) &&
    (input.name === undefined ||
      (typeof input.name === "string" && input.name.length <= 200)) &&
    typeof input.eventId === "string" &&
    /^[A-Za-z0-9._~-]{1,240}$/.test(input.eventId)
  );
}

app.post(
  "/api/welcome",
  bodyLimit({
    maxSize: 16 * 1024,
    onError: (c) => c.json({ error: "Request body is too large" }, 413),
  }),
  async (c) => {
    let input: unknown;
    try {
      input = await c.req.json();
    } catch {
      return c.json({ error: "Request body must be valid JSON" }, 400);
    }

    if (!isWelcomeInput(input)) {
      return c.json({ error: "Invalid email, name, or eventId" }, 400);
    }

    try {
      const result = await ahasend.messages.send(
        {
          sandbox: true,
          from: { email: "hello@yourdomain.com", name: "Your App" },
          recipients: [{ email: input.email, name: input.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.",
        },
        { idempotencyKey: `sandbox-welcome-${input.eventId}` },
      );

      const rejectedCount = result.data.filter((r) => r.status === "error").length;
      if (rejectedCount > 0) {
        console.warn("AhaSend rejected recipients", { rejectedCount });
        return c.json({ error: "Email was not accepted" }, 502);
      }

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

const port = Number(process.env.PORT ?? 3000);
if (!Number.isInteger(port) || port < 1 || port > 65535) {
  throw new Error("PORT must be an integer from 1 to 65535");
}
serve({ fetch: app.fetch, port });

// Add to the imports already at the top of server.ts; `requireEnv` is
// imported there.
import {
  WebhookVerifier,
  isKnownWebhookEvent,
  nextRouteHandler,
} from "@ahasend/sdk/webhooks";

const verifier = new WebhookVerifier(requireEnv("AHASEND_WEBHOOK_SECRET"));

const ahasendWebhook = nextRouteHandler(
  verifier,
  async (event, request) => {
    // Verification already required a non-empty webhook-id. Commit this ID and
    // your durable work in one transaction before acting on the event.
    const webhookId = request.headers.get("webhook-id");

    if (isKnownWebhookEvent(event)) {
      switch (event.type) {
        case "message.delivered":
        case "message.bounced":
        case "message.opened":
          console.log("Received AhaSend webhook", { webhookId, type: event.type });
          break;
      }
    }

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

app.post("/webhooks/ahasend", (c) => ahasendWebhook(c.req.raw));