How to Send Email with AWS Lambda

Transform: AWS::Serverless-2016-10-31

Parameters:
  AhaSendApiKey:
    Type: String
    NoEcho: true
  AhaSendAccountId:
    Type: String

Resources:
  SendEmailFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: .
      Runtime: nodejs22.x
      Handler: src/send.handler
      Timeout: 15
      FunctionUrlConfig:
        AuthType: AWS_IAM
      Environment:
        Variables:
          AHASEND_API_KEY: !Ref AhaSendApiKey
          AHASEND_ACCOUNT_ID: !Ref AhaSendAccountId

import { AhaSendClient, AhaSendAPIError } from "@ahasend/sdk";
import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";

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

const MAX_BODY_BYTES = 16 * 1024;
const EMAIL_PATTERN = /^[^@\s]+@[^@\s.]+(?:\.[^@\s.]+)+$/;
const EVENT_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;

const json = (statusCode: number, body: unknown): APIGatewayProxyResultV2 => ({
  statusCode,
  headers: { "content-type": "application/json" },
  body: JSON.stringify(body),
});

export const handler = async (
  event: APIGatewayProxyEventV2,
): Promise<APIGatewayProxyResultV2> => {
  if (event.requestContext.http.method !== "POST") {
    return json(405, { error: "Method not allowed" });
  }

  // API Gateway caps the request payload at 10 MB and Lambda at 6 MB, so this
  // decode is already bounded; the check below is the application's own limit.
  const raw = event.isBase64Encoded
    ? Buffer.from(event.body ?? "", "base64").toString("utf8")
    : (event.body ?? "");
  if (Buffer.byteLength(raw) > MAX_BODY_BYTES) {
    return json(413, { error: "Request body too large" });
  }

  let parsed: unknown;
  try {
    parsed = JSON.parse(raw);
  } catch {
    return json(400, { error: "Invalid JSON body" });
  }
  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
    return json(400, { error: "Invalid request" });
  }

  const { email, name, event_id: eventId } = parsed as Record<string, unknown>;
  if (typeof email !== "string" || email.length > 320 || !EMAIL_PATTERN.test(email)) {
    return json(400, { error: "Invalid email" });
  }
  if (name !== undefined && (typeof name !== "string" || name.length > 100)) {
    return json(400, { error: "Invalid name" });
  }
  // Caller-owned key: the same event_id must produce the same email, not a second one.
  if (typeof eventId !== "string" || !EVENT_ID_PATTERN.test(eventId)) {
    return json(400, { error: "Invalid event_id" });
  }

  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>",
        text_content: "Welcome aboard",
      },
      { idempotencyKey: `welcome-${eventId}` },
    );

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

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

import {
  WebhookVerifier,
  isKnownWebhookEvent,
  AhaSendWebhookVerificationError,
} from "@ahasend/sdk/webhooks";
import type { APIGatewayProxyEventV2, APIGatewayProxyResultV2 } from "aws-lambda";

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

export const handler = async (
  event: APIGatewayProxyEventV2,
): Promise<APIGatewayProxyResultV2> => {
  const rawBody = event.isBase64Encoded
    ? Buffer.from(event.body ?? "", "base64")
    : (event.body ?? "");

  try {
    const webhookEvent = await verifier.parse(event.headers as Record<string, string>, rawBody);

    if (isKnownWebhookEvent(webhookEvent)) {
      switch (webhookEvent.type) {
        case "message.delivered":
          console.log("AhaSend message delivered");
          break;
        case "message.bounced":
          console.log("AhaSend message bounced");
          break;
      }
    }

    return { statusCode: 200 };
  } catch (err) {
    if (err instanceof AhaSendWebhookVerificationError) {
      return { statusCode: 400 };
    }
    throw err;
  }
};

export const handler = async () => {
  const res = await fetch(
    `https://api.ahasend.com/v2/accounts/${process.env.AHASEND_ACCOUNT_ID}/messages`,
    {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        Authorization: `Bearer ${process.env.AHASEND_API_KEY}`,
      },
      body: JSON.stringify({
        from: { email: "hello@yourdomain.com", name: "Your App" },
        recipients: [{ email: "you@example.com" }],
        subject: "Hello from Lambda",
        html_content: "<strong>It works!</strong>",
        text_content: "It works!",
      }),
    },
  );

  const data = await res.json();
  return { statusCode: res.ok ? 200 : res.status, body: JSON.stringify(data) };
};