@remit/smtp-worker 0.0.30 → 0.0.32

package/src/index.test.ts

@@ -4,7 +4,7 @@
  * that always sees 1 never reaches the settle at all, and the row dead-letters
  * at `sending` exactly as it did before #951.
  *
- * The send handler is replaced here, so this file is about the wiring and not
+ * The processor is replaced here, so this file is about the wiring and not
  * about what the handler does with it — and replacing it is also what keeps
  * the real one's data ports and queue producers out of a unit test.
  */
@@ -14,11 +14,12 @@ import type { Context, SQSEvent } from "aws-lambda";
 
 const receiveCounts: number[] = [];
 
-mock.module("./handlers/send-message.js", {
+mock.module("./processor.js", {
 	namedExports: {
-		handleSendMessage: async (
+		processEvent: async (
 			_event: unknown,
 			_log: unknown,
+			_ctx: unknown,
 			receiveCount: number,
 		): Promise<void> => {
 			receiveCounts.push(receiveCount);
@@ -26,6 +27,10 @@ mock.module("./handlers/send-message.js", {
 	},
 });
 
+mock.module("./lambda-context.js", {
+	namedExports: { buildLambdaSendContext: async () => ({}) },
+});
+
 const { handler, parseReceiveCount } = await import("./index.js");
 
 const context = {
@@ -74,7 +79,7 @@ describe("parseReceiveCount — SQS ApproximateReceiveCount parsing", () => {
 });
 
 describe("the record's delivery count reaches the send handler", () => {
-	it("threads ApproximateReceiveCount through the processor into handleSendMessage", async () => {
+	it("threads ApproximateReceiveCount into the processor", async () => {
 		receiveCounts.length = 0;
 
 		const response = await handler(sendMessageEvent("3"), context);

package/src/index.ts

@@ -9,12 +9,20 @@ import { installNodeLogger, withTelemetry } from "@remit/logger-lambda/node";
 import type { SQSBatchResponse, SQSEvent } from "aws-lambda";
 import type { SmtpEvent } from "./events.js";
 import { smtpFailureKind } from "./failure-kind.js";
+import type { SendMessageContext } from "./handlers/send-message.js";
+import { buildLambdaSendContext } from "./lambda-context.js";
 import { processEvent } from "./processor.js";
 
 installNodeLogger();
 
 const log = createLogger();
 
+let sendContext: Promise<SendMessageContext> | null = null;
+const lambdaSendContext = (): Promise<SendMessageContext> => {
+	sendContext ??= buildLambdaSendContext();
+	return sendContext;
+};
+
 /**
  * Parse SQS's `ApproximateReceiveCount` record attribute (1 on first
  * delivery). Missing/malformed defaults to 1 so a record with no attribute
@@ -44,7 +52,8 @@ export const handler = withTelemetry(
 
 			const queue = queueNameFromEventSource(record.eventSourceARN);
 			const sendStart = Date.now();
-			const failed = await processEvent(smtpEvent, log, receiveCount)
+			const failed = await lambdaSendContext()
+				.then((ctx) => processEvent(smtpEvent, log, ctx, receiveCount))
 				.then(() => {
 					recordQueueEvent({
 						queue,

package/src/lambda-context.test.ts

@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { getSendMessageMaxAttempts } from "./lambda-context.js";
+
+describe("the retry budget is the queue's, read from the environment", () => {
+	it("takes the deployment's own maxReceiveCount when it is set", () => {
+		// The e2e stack sets 1 (`deploy/vps/e2e.env`): its pollers hold a record
+		// for 300s, so a spec cannot wait out three deliveries.
+		assert.equal(
+			getSendMessageMaxAttempts({ SEND_MESSAGE_MAX_ATTEMPTS: "1" }),
+			1,
+		);
+		assert.equal(
+			getSendMessageMaxAttempts({ SEND_MESSAGE_MAX_ATTEMPTS: "5" }),
+			5,
+		);
+	});
+
+	it("falls back to remit-smtp's maxReceiveCount when it is unset or unusable", () => {
+		assert.equal(getSendMessageMaxAttempts({}), 3);
+		assert.equal(
+			getSendMessageMaxAttempts({ SEND_MESSAGE_MAX_ATTEMPTS: "" }),
+			3,
+		);
+		assert.equal(
+			getSendMessageMaxAttempts({ SEND_MESSAGE_MAX_ATTEMPTS: "not-a-number" }),
+			3,
+		);
+		assert.equal(
+			getSendMessageMaxAttempts({ SEND_MESSAGE_MAX_ATTEMPTS: "0" }),
+			3,
+		);
+	});
+});

package/src/lambda-context.ts

@@ -0,0 +1,41 @@
+import { recordSmtpFailure } from "@remit/logger-lambda/metrics";
+import {
+	createMailOAuthService,
+	microsoftProviderConfig,
+} from "@remit/mail-oauth-service";
+import { createSecretsService } from "@remit/secrets-service";
+import { createKmsDataKeyProvider } from "@remit/secrets-service/kms";
+import { directSmtpSocket } from "@remit/smtp-service";
+import { attemptBudget } from "@remit/sqs-client/attempt-budget";
+import { createStandardQueueProducer } from "@remit/sqs-client/producer";
+import { createStorageService } from "@remit/storage-service/s3";
+import { env } from "expect-env";
+import { buildDataPortsFromEnv } from "./data-ports.js";
+import { createAttachmentReader } from "./handlers/attachment-storage.js";
+import type { SendMessageContext } from "./handlers/send-message.js";
+
+export const getSendMessageMaxAttempts = (
+	processEnv: NodeJS.ProcessEnv = process.env,
+): number => attemptBudget("SEND_MESSAGE_MAX_ATTEMPTS", 3, processEnv);
+
+export const buildLambdaSendContext =
+	async (): Promise<SendMessageContext> => ({
+		ports: await buildDataPortsFromEnv(),
+		secrets: createSecretsService(createKmsDataKeyProvider(env.KMS_KEY_ID)),
+		storage: createAttachmentReader(process.env, createStorageService),
+		messageManagement: createStandardQueueProducer({
+			queueUrl: env.SQS_QUEUE_URL_MESSAGE_MGMT,
+		}),
+		tokenService: createMailOAuthService(
+			microsoftProviderConfig({
+				clientId: process.env.MSOAUTH_CLIENT_ID ?? "",
+				clientSecret: process.env.MSOAUTH_CLIENT_SECRET ?? "",
+				overrides: process.env.MSOAUTH_TOKEN_ENDPOINT
+					? { tokenEndpoint: process.env.MSOAUTH_TOKEN_ENDPOINT }
+					: undefined,
+			}),
+		),
+		getSocket: directSmtpSocket,
+		maxAttempts: getSendMessageMaxAttempts(),
+		recordSmtpFailure,
+	});

package/src/ports.ts

@@ -0,0 +1,21 @@
+import type {
+	IAccountRepository,
+	IAddressRepository,
+	IEnvelopeRepository,
+	IMessageRepository,
+	IOutboxAttachmentRepository,
+	IOutboxMessageRepository,
+} from "@remit/data-ports";
+
+/**
+ * The repositories the SMTP send path reads and writes. One neutral seam so the
+ * same handler serves every stack.
+ */
+export interface SmtpDataPorts {
+	account: IAccountRepository;
+	outboxMessage: IOutboxMessageRepository;
+	outboxAttachment: IOutboxAttachmentRepository;
+	address: IAddressRepository;
+	message: IMessageRepository;
+	envelope: IEnvelopeRepository;
+}

package/src/process-bundle.test.ts

@@ -0,0 +1,62 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { describe, it } from "node:test";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+
+const LAMBDA_ONLY = [
+	/(^|\/)aws-lambda(\/|$)/,
+	/(^|\/)@aws-sdk\//,
+	/(^|\/)expect-env(\/|$)/,
+	/(^|\/)sqs-client(\/|$)/,
+	/(^|\/)logger-lambda(\/|$)/,
+	/(^|\/)prom-client(\/|$)/,
+];
+
+const ENV_READERS: readonly string[] = [];
+
+const packageDir = fileURLToPath(new URL("..", import.meta.url));
+
+const bundleInputs = async () => {
+	const { metafile } = await build({
+		absWorkingDir: packageDir,
+		entryPoints: ["src/process.ts"],
+		bundle: true,
+		write: false,
+		metafile: true,
+		platform: "node",
+		format: "esm",
+		logLevel: "silent",
+	});
+	return metafile.inputs;
+};
+
+describe("the ./process entry", () => {
+	it("bundles without the Lambda runtime, the AWS SDK, SQS, expect-env or the Node metrics server", async () => {
+		const reached = Object.entries(await bundleInputs()).flatMap(
+			([path, input]) => [path, ...input.imports.map((entry) => entry.path)],
+		);
+
+		assert.deepEqual(
+			reached.filter((path) =>
+				LAMBDA_ONLY.some((pattern) => pattern.test(path)),
+			),
+			[],
+		);
+	});
+
+	it("reaches no workspace source that reads process.env", async () => {
+		const sources = Object.keys(await bundleInputs()).filter(
+			(path) => !path.startsWith("<") && !path.includes("node_modules/"),
+		);
+
+		assert.deepEqual(
+			sources.filter((path) =>
+				/\bprocess\.env\b/.test(
+					readFileSync(new URL(path, `file://${packageDir}`), "utf8"),
+				),
+			),
+			ENV_READERS,
+		);
+	});
+});

package/src/process.ts

@@ -0,0 +1,11 @@
+export type {
+	AppendSentMessageEvent,
+	SendMessageEvent,
+	SmtpEvent,
+} from "./events.js";
+export type { AttachmentReader } from "./handlers/attachment-storage.js";
+export {
+	handleSendMessage,
+	type SendMessageContext,
+} from "./handlers/send-message.js";
+export type { SmtpDataPorts } from "./ports.js";

package/src/processor.ts

@@ -1,10 +1,14 @@
 import type { Logger } from "@remit/logger";
 import type { SmtpEvent } from "./events.js";
-import { handleSendMessage } from "./handlers/send-message.js";
+import {
+	handleSendMessage,
+	type SendMessageContext,
+} from "./handlers/send-message.js";
 
 export const processEvent = async (
 	event: SmtpEvent,
 	log: Logger,
+	ctx: SendMessageContext,
 	/**
 	 * SQS's own delivery count for the record carrying this event (1 on first
 	 * delivery). Read by SEND_MESSAGE so it knows from it when this is the
@@ -12,11 +16,11 @@ export const processEvent = async (
 	 * record, so it can resolve retry exhaustion into a terminal outcome
 	 * (issue #951) instead of dead-lettering blindly.
 	 */
-	receiveCount = 1,
+	receiveCount: number,
 ): Promise<void> => {
 	switch (event.type) {
 		case "SEND_MESSAGE":
-			return handleSendMessage(event, log, receiveCount);
+			return handleSendMessage(event, ctx, receiveCount);
 		case "PROCESS_OUTBOX":
 			// Future: batch process all queued messages
 			log.info(