@remit/smtp-worker 0.0.25 → 0.0.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/smtp-worker",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -27,6 +27,7 @@
     "@remit/sqs-client": "*",
     "@remit/secrets-service": "*",
     "@remit/smtp-service": "*",
+    "@remit/storage-service": "*",
     "@remit/domain-enums": "*",
     "@remit/mail-oauth-service": "*",
     "@remit/mailbox-service": "*",

package/src/data-ports.ts

@@ -3,6 +3,7 @@ import type {
 	IAddressRepository,
 	IEnvelopeRepository,
 	IMessageRepository,
+	IOutboxAttachmentRepository,
 	IOutboxMessageRepository,
 } from "@remit/data-ports";
 
@@ -13,6 +14,7 @@ import type {
 export interface SmtpDataPorts {
 	account: IAccountRepository;
 	outboxMessage: IOutboxMessageRepository;
+	outboxAttachment: IOutboxAttachmentRepository;
 	address: IAddressRepository;
 	message: IMessageRepository;
 	envelope: IEnvelopeRepository;
@@ -36,6 +38,7 @@ const buildSqliteDataPorts = async (): Promise<SmtpDataPorts> => {
 		DrizzleEnvelopeRepository,
 		DrizzleMessageRepository,
 		messageDataSchema,
+		OutboxAttachmentRepo,
 		OutboxMessageRepo,
 	} = await import("@remit/drizzle-service");
 
@@ -46,6 +49,7 @@ const buildSqliteDataPorts = async (): Promise<SmtpDataPorts> => {
 	return {
 		account: new AccountRepo(db),
 		outboxMessage: new OutboxMessageRepo(db),
+		outboxAttachment: new OutboxAttachmentRepo(db),
 		address: new AddressRepo(db),
 		message: new DrizzleMessageRepository(db),
 		envelope: new DrizzleEnvelopeRepository(db),

package/src/handlers/attachment-storage.test.ts

@@ -0,0 +1,106 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { OutboxAttachmentItem } from "@remit/data-ports";
+import { createMockStorageService } from "@remit/storage-service";
+import {
+	createAttachmentLoader,
+	createAttachmentReader,
+} from "./attachment-storage.js";
+
+describe("createAttachmentReader", () => {
+	it("refuses to read on a Lambda with no bucket, naming the missing setting", () => {
+		let created = 0;
+		const reader = createAttachmentReader(
+			{ AWS_LAMBDA_FUNCTION_NAME: "smtp-worker" },
+			() => {
+				created += 1;
+				return createMockStorageService();
+			},
+		);
+
+		assert.throws(
+			() => reader.retrieveOutboxAttachment("cfg", "acc", "ob", "att"),
+			/S3_BUCKET_NAME is not set on this worker/,
+		);
+		assert.equal(created, 0, "no filesystem fallback was built");
+	});
+
+	it("reads through storage built once, on first use", async () => {
+		const storage = createMockStorageService();
+		await storage.storeOutboxAttachment({
+			accountConfigId: "cfg",
+			accountId: "acc",
+			outboxMessageId: "ob",
+			outboxAttachmentId: "att",
+			content: Buffer.from("bytes"),
+		});
+		let created = 0;
+		const reader = createAttachmentReader(
+			{ AWS_LAMBDA_FUNCTION_NAME: "smtp-worker", S3_BUCKET_NAME: "bucket" },
+			() => {
+				created += 1;
+				return storage;
+			},
+		);
+
+		assert.equal(
+			String(await reader.retrieveOutboxAttachment("cfg", "acc", "ob", "att")),
+			"bytes",
+		);
+		await reader.retrieveOutboxAttachment("cfg", "acc", "ob", "att");
+		assert.equal(created, 1);
+	});
+});
+
+describe("createAttachmentLoader", () => {
+	it("reads the draft's stored files for the tenant it is given", async () => {
+		const storage = createMockStorageService();
+		await storage.storeOutboxAttachment({
+			accountConfigId: "cfg",
+			accountId: "acc",
+			outboxMessageId: "ob",
+			outboxAttachmentId: "att",
+			content: Buffer.from("%PDF"),
+		});
+		const row: OutboxAttachmentItem = {
+			outboxAttachmentId: "att",
+			outboxMessageId: "ob",
+			accountId: "acc",
+			accountConfigId: "cfg",
+			filename: "report.pdf",
+			contentType: "application/pdf",
+			sizeBytes: 4,
+			state: "Stored",
+			storageKey: "k",
+			reservationExpiresAt: 0,
+			createdAt: 0,
+			updatedAt: 0,
+		};
+		const asked: string[][] = [];
+		const load = createAttachmentLoader(
+			storage,
+			async () => ({
+				listByOutboxMessage: async (accountConfigId, outboxMessageId) => {
+					asked.push([accountConfigId, outboxMessageId]);
+					return [row];
+				},
+			}),
+			() => 1_000_000,
+		);
+
+		const files = await load(
+			{ accountConfigId: "cfg", accountId: "acc" },
+			"ob",
+		);
+
+		assert.deepEqual(asked, [["cfg", "ob"]]);
+		assert.deepEqual(
+			files.map((file) => [
+				file.filename,
+				file.contentType,
+				String(file.content),
+			]),
+			[["report.pdf", "application/pdf", "%PDF"]],
+		);
+	});
+});

package/src/handlers/attachment-storage.ts

@@ -0,0 +1,52 @@
+import type { IOutboxAttachmentRepository } from "@remit/data-ports";
+import { loadOutboxAttachmentContents } from "@remit/mailbox-service/outbox-attachment-content";
+import type { MailAttachment } from "@remit/smtp-service";
+import type { StorageService } from "@remit/storage-service";
+import type { SendTenant } from "./send-message-core.js";
+
+export type AttachmentReader = Pick<StorageService, "retrieveOutboxAttachment">;
+
+/**
+ * Where this worker reads a message's files from, built on the first read.
+ *
+ * Without a bucket the storage factory falls back to the local filesystem,
+ * which a Lambda does not have: every read would come back empty and blame the
+ * file. The check runs on the first read rather than at start, so a deployment
+ * not yet given the bucket still sends every message that carries no files.
+ */
+export const createAttachmentReader = (
+	processEnv: NodeJS.ProcessEnv,
+	createStorage: () => StorageService,
+): AttachmentReader => {
+	let storage: StorageService | null = null;
+	return {
+		retrieveOutboxAttachment: (...args) => {
+			if (processEnv.AWS_LAMBDA_FUNCTION_NAME && !processEnv.S3_BUCKET_NAME) {
+				throw new Error(
+					"S3_BUCKET_NAME is not set on this worker, so it has no attachment storage to read from",
+				);
+			}
+			if (!storage) storage = createStorage();
+			return storage.retrieveOutboxAttachment(...args);
+		},
+	};
+};
+
+/** The files a message goes out with, read from this worker's ports and storage. */
+export const createAttachmentLoader =
+	(
+		reader: AttachmentReader,
+		getRepository: () => Promise<
+			Pick<IOutboxAttachmentRepository, "listByOutboxMessage">
+		>,
+		now: () => number = Date.now,
+	) =>
+	async (
+		tenant: SendTenant,
+		outboxMessageId: string,
+	): Promise<MailAttachment[]> =>
+		loadOutboxAttachmentContents(
+			{ attachments: await getRepository(), storage: reader },
+			{ ...tenant, outboxMessageId },
+			Math.floor(now() / 1000),
+		);

package/src/handlers/send-message-core.ts

@@ -8,9 +8,11 @@ import { AccountAuthType, OutboxMessageStatus } from "@remit/domain-enums";
 import { type Logger, recordSmtpFailure } from "@remit/logger-lambda";
 import { RefreshTokenError } from "@remit/mail-oauth-service";
 import type { CredentialResolution } from "@remit/mailbox-service/account-credentials";
+import { OutboxAttachmentUnavailableError } from "@remit/mailbox-service/outbox-attachment-content";
 import type { SecretsService } from "@remit/secrets-service";
 import {
 	buildMailMessage,
+	type MailAttachment,
 	type SendResult,
 	SmtpConnectionError,
 	type sendMail,
@@ -87,12 +89,23 @@ export interface SendMessageDeps {
 	 */
 	resolveCredentials: (account: AccountItem) => Promise<CredentialResolution>;
 	/**
-	 * Persist the account's connectionState. Called when a terminal OAuth/SMTP
-	 * auth failure is detected so the account is fenced off until the user
-	 * re-auths (mirrors the IMAP withOAuthLifecycle contract).
+	 * Persist the account's connectionState, and with it the sentence the
+	 * account card shows. Called when a terminal OAuth/SMTP auth failure is
+	 * detected so the account is fenced off until the user re-auths (mirrors the
+	 * IMAP withOAuthLifecycle contract). `lastError` carries the server's own
+	 * words when the refusal came with any, and its absence clears the stored
+	 * reason rather than leaving an older failure to describe this one.
 	 */
-	updateConnectionState: (accountId: string, state: string) => Promise<void>;
+	updateConnectionState: (
+		accountId: string,
+		state: string,
+		lastError?: string,
+	) => Promise<void>;
 	send: typeof sendMail;
+	loadAttachments: (
+		tenant: SendTenant,
+		outboxMessageId: string,
+	) => Promise<MailAttachment[]>;
 	emitAppendSentMessage: (
 		accountId: string,
 		outboxMessageId: string,
@@ -149,6 +162,16 @@ const SENDABLE_STATUSES: ReadonlySet<OutboxMessageItem["status"]> = new Set([
 	OutboxMessageStatus.sending,
 ]);
 
+/**
+ * Why a message stopped at its files, in words the Outbox can show. A `failed`
+ * row can be edited, sent again and discarded (#933), so the sentence names
+ * the file and what to do about it.
+ */
+const attachmentFailureReason = (error: unknown): string =>
+	error instanceof OutboxAttachmentUnavailableError
+		? `${error.message}, so this message was not sent. Remove "${error.filename}", attach it again, and send.`
+		: `The files on this message could not be read (${error instanceof Error ? error.message : String(error)}), so it was not sent. Send it again.`;
+
 export const getSendMessageMaxAttempts = (
 	processEnv: NodeJS.ProcessEnv = process.env,
 ): number => attemptBudget("SEND_MESSAGE_MAX_ATTEMPTS", 3, processEnv);
@@ -268,10 +291,14 @@ export const sendMessage = async (
 				throw err;
 			}
 			log.warn(
-				{ accountId, errorKind: err.kind },
+				{ accountId, errorKind: err.kind, error: err.message },
 				"SMTP auth rejected; marking account reauth_required",
 			);
-			await deps.updateConnectionState(accountId, "reauth_required");
+			await deps.updateConnectionState(
+				accountId,
+				"reauth_required",
+				err.message,
+			);
 			await settleBlockedOnReauth();
 			return; // ACK — do not retry
 		}
@@ -290,9 +317,38 @@ export const sendMessage = async (
 	}
 	const smtpConfig = resolved.config;
 
+	// Below the budget a storage hiccup is retried like any other; at it the
+	// record would dead-letter with the row at `queued`, which can be neither
+	// sent again nor discarded (#845.8), so the row settles `failed` instead.
+	const attachments = await deps
+		.loadAttachments(
+			{ accountConfigId, accountId: account.accountId },
+			outboxMessageId,
+		)
+		.catch(async (error: unknown) => {
+			if (receiveCount < SEND_MESSAGE_MAX_ATTEMPTS) throw error;
+			log.error(
+				{ outboxMessageId, receiveCount, error: String(error) },
+				"Attachments could not be loaded; settling the row as failed",
+			);
+			if (outbox.status !== OutboxMessageStatus.draft) {
+				await deps.updateOutboxIfStatus(
+					accountConfigId,
+					outboxMessageId,
+					outbox.status,
+					{
+						status: OutboxMessageStatus.failed,
+						lastError: attachmentFailureReason(error),
+					},
+				);
+			}
+			return null;
+		});
+	if (attachments === null) return;
+
 	await deps.updateOutboxStatus(accountConfigId, outboxMessageId, "sending");
 
-	const message = buildMailMessage(outbox);
+	const message = buildMailMessage(outbox, attachments);
 
 	log.info(
 		{ outboxMessageId, to: outbox.toAddresses, subject: outbox.subject },
@@ -311,10 +367,14 @@ export const sendMessage = async (
 			account.authType === AccountAuthType.OauthMicrosoft
 		) {
 			log.warn(
-				{ accountId, errorKind: err.kind },
+				{ accountId, errorKind: err.kind, error: err.message },
 				"SMTP auth rejected during send; marking account reauth_required",
 			);
-			await deps.updateConnectionState(accountId, "reauth_required");
+			await deps.updateConnectionState(
+				accountId,
+				"reauth_required",
+				err.message,
+			);
 			await settleBlockedOnReauth(OutboxMessageStatus.sending);
 			return; // ACK — do not retry
 		}

package/src/handlers/send-message.test.ts

@@ -7,11 +7,17 @@ import type {
 } from "@remit/data-ports";
 import { AccountAuthType } from "@remit/domain-enums";
 import { RefreshTokenError } from "@remit/mail-oauth-service";
+import { OutboxAttachmentUnavailableError } from "@remit/mailbox-service/outbox-attachment-content";
 import {
 	type EncryptedPayload,
 	serializeEncryptedPayload,
 } from "@remit/secrets-service";
-import { type SendResult, SmtpConnectionError } from "@remit/smtp-service";
+import {
+	type MailAttachment,
+	type MailMessage,
+	type SendResult,
+	SmtpConnectionError,
+} from "@remit/smtp-service";
 import type { SendMessageEvent } from "../events.js";
 import {
 	getSendMessageMaxAttempts,
@@ -104,6 +110,8 @@ const buildDeps = (
 		appendThrows?: Error;
 		resolveCredentials?: SendMessageDeps["resolveCredentials"];
 		send?: SendMessageDeps["send"];
+		attachments?: MailAttachment[];
+		attachmentsFail?: Error;
 	} = {},
 ): { deps: SendMessageDeps; recorded: Recorded } => {
 	const recorded: Recorded = {
@@ -194,6 +202,13 @@ const buildDeps = (
 					}
 				);
 			}),
+		loadAttachments: async (tenant, outboxMessageId) => {
+			assert.equal(tenant.accountConfigId, account.accountConfigId);
+			assert.equal(tenant.accountId, account.accountId);
+			assert.equal(outboxMessageId, outbox.outboxMessageId);
+			if (options.attachmentsFail) throw options.attachmentsFail;
+			return options.attachments ?? [];
+		},
 		emitAppendSentMessage: async (accountId, outboxMessageId) => {
 			recorded.appendCalls.push({ accountId, outboxMessageId });
 			if (options.appendThrows) throw options.appendThrows;
@@ -225,6 +240,65 @@ const event: SendMessageEvent = {
 };
 
 describe("sendMessage handler", () => {
+	it("retries a message whose files could not be read, below the budget", async () => {
+		const { deps, recorded } = buildDeps({
+			outbox: buildOutbox({ status: "queued" }),
+			attachmentsFail: new OutboxAttachmentUnavailableError(
+				"payroll.xlsx",
+				"nothing is stored at key/payroll",
+			),
+		});
+
+		await assert.rejects(() => sendMessage(event, silentLogger, deps, 1));
+
+		assert.equal(recorded.sendCalls, 0);
+		assert.deepEqual(recorded.updates, []);
+		assert.deepEqual(recorded.statuses, [], "never moved to sending");
+	});
+
+	it("settles a message whose files cannot be read as failed, naming the file, at the budget", async () => {
+		const { deps, recorded } = buildDeps({
+			outbox: buildOutbox({ status: "queued" }),
+			attachmentsFail: new OutboxAttachmentUnavailableError(
+				"payroll.xlsx",
+				"nothing is stored at key/payroll",
+			),
+		});
+
+		await sendMessage(event, silentLogger, deps, SEND_MESSAGE_MAX_ATTEMPTS);
+
+		assert.equal(recorded.sendCalls, 0);
+		assert.equal(recorded.updates.length, 1);
+		assert.equal(recorded.updates[0].patch.status, "failed");
+		assert.equal(
+			recorded.updates[0].patch.lastError,
+			'"payroll.xlsx" could not be read: nothing is stored at key/payroll, so this message was not sent. Remove "payroll.xlsx", attach it again, and send.',
+		);
+	});
+
+	it("sends every file the draft carries as a part of the message", async () => {
+		const attachments: MailAttachment[] = [
+			{
+				filename: "report.pdf",
+				contentType: "application/pdf",
+				content: Buffer.from("%PDF-1.4"),
+			},
+		];
+		const sent: MailMessage[] = [];
+		const { deps } = buildDeps({
+			attachments,
+			send: async (_config, message) => {
+				sent.push(message);
+				return { success: true, messageId: "smtp-mid-1", isTransient: false };
+			},
+		});
+
+		await sendMessage(event, silentLogger, deps);
+
+		assert.equal(sent.length, 1);
+		assert.deepEqual(sent[0].attachments, attachments);
+	});
+
 	it("marks status `blocked` when SMTP is disabled — never `sent`", async () => {
 		const { deps, recorded } = buildDeps({
 			account: buildAccount({ smtpEnabled: false }),

package/src/handlers/send-message.ts

@@ -21,9 +21,14 @@ import {
 } from "@remit/secrets-service";
 import { sendMail } from "@remit/smtp-service";
 import { createQueueProducer } from "@remit/sqs-client/producer";
+import { createStorageService } from "@remit/storage-service/s3";
 import { env } from "expect-env";
 import { buildDataPortsFromEnv, type SmtpDataPorts } from "../data-ports.js";
 import type { SendMessageEvent } from "../events.js";
+import {
+	createAttachmentLoader,
+	createAttachmentReader,
+} from "./attachment-storage.js";
 import { sendMessage } from "./send-message-core.js";
 
 // The data ports are resolved lazily and cached, not at module load: the
@@ -35,6 +40,11 @@ const getPorts = (): Promise<SmtpDataPorts> => {
 	return portsPromise;
 };
 
+const loadAttachments = createAttachmentLoader(
+	createAttachmentReader(process.env, createStorageService),
+	async () => (await getPorts()).outboxAttachment,
+);
+
 const dataKeyProvider = createKmsDataKeyProvider(env.KMS_KEY_ID);
 const secrets = createSecretsService(dataKeyProvider);
 
@@ -162,14 +172,22 @@ export const handleSendMessage = (
 			secrets,
 			resolveCredentials: (account) =>
 				resolveConnectionCredentials(account, credentialDeps),
-			updateConnectionState: async (id, state) => {
+			// A flip with no reason of its own removes the stored one, so the card
+			// never reads back a failure the account has moved on from.
+			updateConnectionState: async (id, state, lastError) => {
 				const { account } = await getPorts();
-				await account.update(id, {
-					connectionState:
-						state as (typeof ConnectionState)[keyof typeof ConnectionState],
-				});
+				await account.update(
+					id,
+					{
+						connectionState:
+							state as (typeof ConnectionState)[keyof typeof ConnectionState],
+						lastError,
+					},
+					lastError === undefined ? ["lastError"] : undefined,
+				);
 			},
 			send: sendMail,
+			loadAttachments,
 			emitAppendSentMessage,
 			engagement: {
 				resolveAddressId: deriveAddressId,