How to Send Email with Deno and Deno Deploy

import { AhaSendClient } from "npm:@ahasend/sdk";
try {
  const client = new AhaSendClient({ apiKey: Deno.env.get("AHASEND_API_KEY"), accountId: Deno.env.get("AHASEND_ACCOUNT_ID") });
  const result = await client.messages.send({
    from: { email: Deno.env.get("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.");
  Deno.exit(1);
}

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

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

import { AhaSendAPIError, isAhaSendError } from "@ahasend/sdk";
import { ahasend } from "./lib/ahasend.ts";
import { handleAhaSendWebhook } from "./webhook.ts";
// Application-owned: implement signup lookup and authorization before using real mail.
import { requireAuthenticatedSignup } from "./lib/auth.ts";

Deno.serve(async (req) => {
  const url = new URL(req.url);

  if (req.method === "POST" && url.pathname === "/api/welcome") {
    const user = await requireAuthenticatedSignup(req);
    if (!user) return new Response(null, { status: 401 });

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

      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 === 0 ? 202 : 502 },
      );
    } catch (err) {
      if (isAhaSendError(err)) {
        console.error("AhaSend request failed", {
          ...(err instanceof AhaSendAPIError ? { status: err.status, requestId: err.requestId } : {}),
          errorCode: err.code,
        });
        return Response.json({ error: "Failed to send email" }, { status: 502 });
      }
      console.error("Unexpected welcome-email handler failure");
      return Response.json({ error: "Failed to send email" }, { status: 500 });
    }
  }

  if (req.method === "POST" && url.pathname === "/webhooks/ahasend") {
    return handleAhaSendWebhook(req);
  }
  return new Response("Not found", { status: 404 });
});

import { AhaSendWebhookVerificationError, WebhookVerifier, isKnownWebhookEvent } from "@ahasend/sdk/webhooks";
// Application-owned: provide atomic durable storage as described below.
import { webhookDeliveries } from "./lib/webhook-store.ts";

const verifier = new WebhookVerifier(Deno.env.get("AHASEND_WEBHOOK_SECRET")!);
const MAX_WEBHOOK_BODY_BYTES = 30_000_000;

class WebhookBodyTooLargeError extends Error {}

async function readRawBody(req: Request): Promise<Uint8Array> {
  if (!req.body) return new Uint8Array();

  const reader = req.body.getReader();
  const chunks: Uint8Array[] = [];
  let size = 0;
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) break;
      size += value.byteLength;
      if (size > MAX_WEBHOOK_BODY_BYTES) {
        await reader.cancel();
        throw new WebhookBodyTooLargeError();
      }
      chunks.push(value);
    }
  } finally {
    reader.releaseLock();
  }

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

export async function handleAhaSendWebhook(req: Request): Promise<Response> {
  let event;
  try {
    event = await verifier.parse(req.headers, await readRawBody(req));
  } catch (error) {
    if (error instanceof WebhookBodyTooLargeError) {
      return new Response(null, { status: 413 });
    }
    if (error instanceof AhaSendWebhookVerificationError) {
      return new Response(null, { status: error.reason === "body_too_large" ? 413 : 400 });
    }
    return new Response(null, { status: 500 });
  }

  if (!isKnownWebhookEvent(event)) return new Response(null, { status: 204 });
  const webhookId = req.headers.get("webhook-id");
  if (!webhookId) return new Response(null, { status: 400 });

  try {
    const accepted = await webhookDeliveries.enqueueOnce(webhookId, event);
    return new Response(null, { status: accepted ? 202 : 200 });
  } catch {
    return new Response(null, { status: 500 });
  }
}