How to Send Email with Encore.ts

import { secret } from "encore.dev/config";
import { AhaSendClient } from "@ahasend/sdk";

const ahasendApiKey = secret("AhaSendApiKey");
const ahasendAccountId = secret("AhaSendAccountId");

let client: AhaSendClient | undefined;
let clientApiKey: string | undefined;

export function ahasend(): AhaSendClient {
  const apiKey = ahasendApiKey();
  if (client === undefined || clientApiKey !== apiKey) {
    client = new AhaSendClient({ apiKey, accountId: ahasendAccountId() });
    clientApiKey = apiKey;
  }
  return client;
}

import { api, APIError } from "encore.dev/api";
import { getAuthData } from "~encore/auth";
import { createHash } from "node:crypto";
import { AhaSendAPIError, isAhaSendError } from "@ahasend/sdk";
import { ahasend } from "./ahasend";

interface SendWelcomeResponse {
  statuses: string[];
}

export const sendWelcome = api(
  { expose: true, auth: true, method: "POST", path: "/welcome" },
  async (): Promise<SendWelcomeResponse> => {
    const user = getAuthData()!;
    const welcomeKey = createHash("sha256").update(user.userID).digest("hex");

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

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

      return { statuses: result.data.map((r) => r.status) }; // ["queued"]
    } catch (err) {
      if (err instanceof AhaSendAPIError) {
        console.error("AhaSend request failed", {
          status: err.status,
          requestId: err.requestId,
          errorCode: err.code,
        });
      } else if (isAhaSendError(err)) {
        console.error("AhaSend request failed", { errorCode: err.code });
      } else {
        console.error("Welcome email request failed");
      }
      throw APIError.internal("unable to send welcome email");
    }
  },
);

import { api } from "encore.dev/api";
import { secret } from "encore.dev/config";
import type { IncomingMessage } from "node:http";
import {
  WebhookVerifier,
  AhaSendWebhookVerificationError,
} from "@ahasend/sdk/webhooks";

const ahasendWebhookSecret = secret("AhaSendWebhookSecret");

let verifier: WebhookVerifier | undefined;
let verifierSecret: string | undefined;
const maxWebhookBodyBytes = 1_000_000;

function webhookVerifier(): WebhookVerifier {
  const secretValue = ahasendWebhookSecret();
  if (verifier === undefined || verifierSecret !== secretValue) {
    verifier = new WebhookVerifier(secretValue);
    verifierSecret = secretValue;
  }
  return verifier;
}

class WebhookBodyTooLargeError extends Error {}

async function readRawBody(req: IncomingMessage): Promise<Buffer> {
  return new Promise((resolve, reject) => {
    const chunks: Buffer[] = [];
    let size = 0;

    const cleanup = () => {
      req.off("data", onData);
      req.off("end", onEnd);
      req.off("error", onError);
    };
    const onData = (chunk: Buffer | string) => {
      const bytes = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
      size += bytes.byteLength;
      if (size > maxWebhookBodyBytes) {
        cleanup();
        reject(new WebhookBodyTooLargeError());
        return;
      }
      chunks.push(bytes);
    };
    const onEnd = () => {
      cleanup();
      resolve(Buffer.concat(chunks, size));
    };
    const onError = (err: Error) => {
      cleanup();
      reject(err);
    };

    req.on("data", onData);
    req.on("end", onEnd);
    req.on("error", onError);
  });
}

export const ahasendWebhook = api.raw(
  {
    expose: true,
    path: "/webhooks/ahasend",
    method: "POST",
    bodyLimit: maxWebhookBodyBytes,
  },
  async (req, resp) => {
    try {
      const verify = webhookVerifier();
      const rawBody = await readRawBody(req);
      await verify.parse(req.headers, rawBody);

      resp.writeHead(200);
      resp.end();
    } catch (err) {
      if (err instanceof WebhookBodyTooLargeError) {
        resp.writeHead(413);
        resp.end();
        return;
      }
      if (err instanceof AhaSendWebhookVerificationError) {
        resp.writeHead(400);
        resp.end();
        return;
      }
      console.error("AhaSend webhook processing failed");
      resp.writeHead(500);
      resp.end();
    }
  },
);