@remit/mailbox-service 0.0.111 → 0.0.112

package/src/outbox-failed-recovery.test.ts

@@ -1,344 +1,276 @@
-/**
- * The two ways an outbox row used to become unusable without ever leaving.
- *
- * `createAndSend` wrote the row at `queued` and then enqueued. A throw from the
- * enqueue left it there, and `queued` is accepted by neither `send` nor
- * `deleteDraft` — the message could be neither sent nor discarded (#936).
- *
- * A send that failed settled at `failed`, and `updateDraft` refused anything
- * but `draft`. Retry re-queued the same envelope and Edit took a 409 on the
- * flush that precedes the send, so a message refused for a bad address had no
- * way back to sent short of retyping it (#933).
- *
- * Where a stranded row settles is the load-bearing part. Not `draft`: a throw
- * from `SendMessage` says the response was lost, not that the broker refused
- * the event, and `draft` is inside the SMTP worker's send fence — a row put
- * there is sendable both by the event that landed anyway and by the user
- * pressing Send. `failed` is outside that fence and, since #933, is a row the
- * user can still edit and send.
- */
-
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	IAccountRepository,
-	IOutboxMessageRepository,
-	OutboxMessageItem,
-	UpdateOutboxMessageInput,
-} from "@remit/data-ports";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { AccountItem, OutboxMessageItem } from "@remit/data-ports";
 import { ConflictError } from "@remit/data-ports/errors";
 import { OutboxMessageStatus } from "@remit/domain-enums";
-import type { OutboxAttachmentService } from "./outbox-attachment.js";
+import { OutboxAttachmentService } from "./outbox-attachment.js";
 import { OutboxQueueService } from "./outbox-queue.js";
+import {
+	beforeNext,
+	captureQueue,
+	openStore,
+	type QueueCapture,
+	type QueuedEvent,
+	type Store,
+	seedAccount,
+} from "./test-helpers/test-store.js";
+
+let store: Store;
+let account: AccountItem;
+let capture: QueueCapture;
+let enqueued: QueuedEvent[];
+let enqueueFails: Error | undefined;
+let whileEnqueueing: () => Promise<unknown>;
+
+beforeEach(async () => {
+	store = await openStore();
+	account = await seedAccount(store);
+	enqueueFails = undefined;
+	whileEnqueueing = async () => {};
+	capture = captureQueue();
+	capture.answer(async () => {
+		await whileEnqueueing();
+		if (enqueueFails) throw enqueueFails;
+		return {};
+	});
+	enqueued = capture.sent;
+});
+
+afterEach(async () => {
+	capture.restore();
+	await store.close();
+});
 
-const ACCOUNT_CONFIG_ID = "cfg-1";
-const ACCOUNT_ID = "acc-1";
-const OUTBOX_MESSAGE_ID = "ob-1";
+const queue = () =>
+	new OutboxQueueService({
+		outboxMessageService: store.outboxMessage,
+		outboxAttachmentService: new OutboxAttachmentService({
+			outboxMessageService: store.outboxMessage,
+			outboxAttachmentService: store.outboxAttachment,
+			storage: store.storage(),
+		}),
+		accountService: store.account,
+		sqsSmtpQueueUrl: "http://localhost/queue",
+	});
 
-const row = (overrides: Partial<OutboxMessageItem>): OutboxMessageItem =>
-	({
-		outboxMessageId: OUTBOX_MESSAGE_ID,
-		accountId: ACCOUNT_ID,
-		accountConfigId: ACCOUNT_CONFIG_ID,
+const message = (status: OutboxMessageItem["status"]) =>
+	store.outboxMessage.create({
+		accountId: account.accountId,
+		accountConfigId: account.accountConfigId,
 		fromAddress: "me@example.com",
 		toAddresses: ["typo@exmaple.com"],
-		ccAddresses: [],
-		bccAddresses: [],
-		references: [],
 		messageIdValue: "<m1@example.com>",
 		subject: "Invoice",
 		textBody: "Attached.",
-		status: OutboxMessageStatus.draft,
-		createdAt: 0,
-		updatedAt: 0,
-		...overrides,
-	}) as OutboxMessageItem;
-
-interface ConditionalWrite {
-	expected: OutboxMessageItem["status"];
-	input: UpdateOutboxMessageInput;
-	applied: boolean;
-}
-
-interface Harness {
-	service: OutboxQueueService;
-	enqueued: string[];
-	createdStatuses: string[];
-	writes: ConditionalWrite[];
-	/** What the row holds now, after every write this harness applied. */
-	status: () => OutboxMessageItem["status"];
-}
-
-interface HarnessOptions {
-	enqueueFails?: Error;
-	settleFails?: Error;
-	/** Moves the row the instant the service reads it, as a racing writer would. */
-	movesOnRead?: OutboxMessageItem["status"];
-}
-
-const createHarness = (
-	stored: OutboxMessageItem,
-	options: HarnessOptions = {},
-): Harness => {
-	let current = stored;
-
-	const harness: Harness = {
-		service: undefined as unknown as OutboxQueueService,
-		enqueued: [],
-		createdStatuses: [],
-		writes: [],
-		status: () => current.status,
-	};
-
-	const outboxMessageService = {
-		get: async () => {
-			const seen = current;
-			if (options.movesOnRead) {
-				current = row({ ...current, status: options.movesOnRead });
-			}
-			return seen;
-		},
-		create: async (input: Record<string, unknown>) => {
-			current = row(input as Partial<OutboxMessageItem>);
-			harness.createdStatuses.push(current.status);
-			return current;
-		},
-		updateIfStatus: async (
-			_configId: string,
-			_id: string,
-			expected: OutboxMessageItem["status"],
-			input: UpdateOutboxMessageInput,
-		) => {
-			if (options.settleFails && input.status === OutboxMessageStatus.failed) {
-				throw options.settleFails;
-			}
-			const applied = current.status === expected;
-			harness.writes.push({ expected, input, applied });
-			if (!applied) return null;
-			current = row({ ...current, ...input });
-			return current;
-		},
-	} as unknown as IOutboxMessageRepository;
-
-	harness.service = new OutboxQueueService({
-		outboxMessageService,
-		outboxAttachmentService: {
-			unfinishedUpload: async () => undefined,
-		} as unknown as OutboxAttachmentService,
-		accountService: {
-			get: async () => ({ syncedServices: ["Mail"] }),
-		} as unknown as IAccountRepository,
-		sqsSmtpQueueUrl: "http://localhost/queue",
-		sqsClient: {
-			send: async (command: { input: { MessageBody: string } }) => {
-				if (options.enqueueFails) throw options.enqueueFails;
-				harness.enqueued.push(command.input.MessageBody);
-				return {};
-			},
-		} as never,
+		status,
 	});
 
-	return harness;
-};
-
-const createInput = {
-	accountId: ACCOUNT_ID,
-	accountConfigId: ACCOUNT_CONFIG_ID,
+const createInput = () => ({
+	accountId: account.accountId,
+	accountConfigId: account.accountConfigId,
 	fromAddress: "me@example.com",
 	toAddresses: ["them@example.com"],
 	subject: "Invoice",
 	textBody: "Attached.",
-};
+});
 
-const applied = (harness: Harness): UpdateOutboxMessageInput[] =>
-	harness.writes.filter((write) => write.applied).map((write) => write.input);
+const current = (outboxMessageId: string) =>
+	store.outboxMessage.get(account.accountConfigId, outboxMessageId);
 
-describe("an enqueue that reports a failure", () => {
-	it("settles the new row of createAndSend at `failed`, never at `queued`", async () => {
-		const harness = createHarness(row({}), {
-			enqueueFails: new Error("SQS unavailable"),
-		});
+const all = async () =>
+	(await store.outboxMessage.listByAccount(account.accountId)).items;
+
+const isConflict = (error: unknown) => {
+	assert.ok(error instanceof ConflictError);
+	assert.equal(error.statusCode, 409);
+	return true;
+};
+
+describe("an enqueue that fails", () => {
+	it("settles the new row of createAndSend at failed, saying why, and still reports the failure", async () => {
+		enqueueFails = new Error("SQS unavailable");
 
 		await assert.rejects(
-			() => harness.service.createAndSend(createInput),
+			queue().createAndSend(createInput()),
 			/SQS unavailable/,
-			"the caller still hears the failure",
 		);
 
-		assert.deepEqual(harness.createdStatuses, [OutboxMessageStatus.queued]);
-		assert.equal(harness.status(), OutboxMessageStatus.failed);
+		const [row] = await all();
+		assert.equal(row.status, OutboxMessageStatus.failed);
+		assert.match(
+			String(row.lastError),
+			/could not be handed to the outgoing queue/,
+		);
 	});
 
-	it("settles at `failed` rather than `draft` — the event may have landed", async () => {
-		// `draft` is inside the worker's send fence, so a row put back there is
-		// sent by the landed event and sendable again by hand: two copies of one
-		// message. This is the assertion that keeps it out.
-		const harness = createHarness(row({}), {
-			enqueueFails: new Error("SQS unavailable"),
-		});
+	it("takes a sent draft to failed, never back to draft", async () => {
+		const draft = await message(OutboxMessageStatus.draft);
+		enqueueFails = new Error("SQS unavailable");
 
-		await assert.rejects(() => harness.service.createAndSend(createInput));
+		await assert.rejects(
+			queue().send(account.accountConfigId, draft.outboxMessageId),
+		);
 
-		assert.notEqual(harness.status(), OutboxMessageStatus.draft);
-		assert.match(
-			String(applied(harness).at(-1)?.lastError),
-			/could not be handed to the outgoing queue/,
-			"and it says why, where the Outbox shows it",
+		assert.equal(
+			(await current(draft.outboxMessageId)).status,
+			OutboxMessageStatus.failed,
 		);
 	});
 
-	it("takes a draft that was sent to `failed`, not back to `draft`", async () => {
-		const harness = createHarness(row({}), {
-			enqueueFails: new Error("SQS unavailable"),
-		});
+	it("returns a blocked row to blocked", async () => {
+		const blocked = await message(OutboxMessageStatus.blocked);
+		enqueueFails = new Error("SQS unavailable");
 
-		await assert.rejects(() =>
-			harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
+		await assert.rejects(
+			queue().send(account.accountConfigId, blocked.outboxMessageId),
 		);
 
-		assert.equal(harness.status(), OutboxMessageStatus.failed);
+		assert.equal(
+			(await current(blocked.outboxMessageId)).status,
+			OutboxMessageStatus.blocked,
+		);
 	});
 
-	it("returns a `blocked` row to `blocked` — outside the fence, and the reason stands", async () => {
-		const harness = createHarness(
-			row({ status: OutboxMessageStatus.blocked }),
-			{
-				enqueueFails: new Error("SQS unavailable"),
-			},
-		);
+	it("leaves a row the worker already took alone", async () => {
+		const draft = await message(OutboxMessageStatus.draft);
+		enqueueFails = new Error("SQS timed out after the event landed");
+		whileEnqueueing = () =>
+			store.outboxMessage.updateStatus(
+				account.accountConfigId,
+				draft.outboxMessageId,
+				OutboxMessageStatus.sending,
+			);
 
-		await assert.rejects(() =>
-			harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
+		await assert.rejects(
+			queue().send(account.accountConfigId, draft.outboxMessageId),
 		);
 
-		assert.equal(harness.status(), OutboxMessageStatus.blocked);
+		assert.equal(
+			(await current(draft.outboxMessageId)).status,
+			OutboxMessageStatus.sending,
+		);
 	});
 
-	it("only settles a row still at `queued` — the worker may already hold it", async () => {
-		const harness = createHarness(row({}), {
-			enqueueFails: new Error("SQS unavailable"),
-		});
-
-		await assert.rejects(() => harness.service.createAndSend(createInput));
+	it("keeps the row queued when the enqueue succeeds", async () => {
+		await queue().createAndSend(createInput());
 
-		const settle = harness.writes.at(-1);
-		assert.equal(settle?.expected, OutboxMessageStatus.queued);
+		const [row] = await all();
+		assert.equal(row.status, OutboxMessageStatus.queued);
+		assert.equal(enqueued.length, 1);
 	});
+});
 
-	it("still reports the enqueue failure when the settle write also fails", async () => {
-		// The settle is the repair, not the failure. Replacing the enqueue error
-		// with the repair's would name the wrong cause and hide the row's state.
-		const harness = createHarness(row({}), {
-			enqueueFails: new Error("SQS unavailable"),
-			settleFails: new Error("database unreachable"),
-		});
+describe("a row the worker settled", () => {
+	it("is sendable again from failed, and discardable", async () => {
+		const failed = await message(OutboxMessageStatus.failed);
 
-		await assert.rejects(
-			() => harness.service.createAndSend(createInput),
-			/SQS unavailable/,
+		await queue().send(account.accountConfigId, failed.outboxMessageId);
+		assert.equal(
+			(await current(failed.outboxMessageId)).status,
+			OutboxMessageStatus.queued,
 		);
+
+		const other = await message(OutboxMessageStatus.failed);
+		await queue().deleteDraft(account.accountConfigId, other.outboxMessageId);
+		await assert.rejects(current(other.outboxMessageId));
 	});
 
-	it("keeps the row at `queued` when the enqueue succeeds", async () => {
-		const harness = createHarness(row({}));
+	it("is discardable but never sendable from unfiled", async () => {
+		const unfiled = await message(OutboxMessageStatus.unfiled);
 
-		await harness.service.createAndSend(createInput);
+		await assert.rejects(
+			queue().send(account.accountConfigId, unfiled.outboxMessageId),
+			/cannot be sent again/,
+		);
+		assert.deepEqual(enqueued, []);
 
-		assert.equal(harness.enqueued.length, 1);
-		assert.deepEqual(harness.writes, [], "nothing walked the row back");
+		await queue().deleteDraft(account.accountConfigId, unfiled.outboxMessageId);
+		await assert.rejects(current(unfiled.outboxMessageId));
 	});
 });
 
 describe("correcting a message that failed to send", () => {
-	it("accepts the edit and returns the row to `draft`", async () => {
-		const harness = createHarness(row({ status: OutboxMessageStatus.failed }));
+	it("accepts the edit, keeps the content and returns the row to draft", async () => {
+		const failed = await message(OutboxMessageStatus.failed);
 
-		const updated = await harness.service.updateDraft(
-			ACCOUNT_CONFIG_ID,
-			OUTBOX_MESSAGE_ID,
+		const updated = await queue().updateDraft(
+			account.accountConfigId,
+			failed.outboxMessageId,
 			{ toAddresses: ["them@example.com"] },
 		);
 
-		assert.deepEqual(applied(harness), [
-			{
-				status: OutboxMessageStatus.draft,
-				toAddresses: ["them@example.com"],
-			},
-		]);
 		assert.equal(updated.status, OutboxMessageStatus.draft);
-		assert.equal(updated.subject, "Invoice", "its content came with it");
+		assert.deepEqual(updated.toAddresses, ["them@example.com"]);
+		assert.equal(updated.subject, "Invoice");
 	});
 
 	it("sends the corrected message", async () => {
-		const harness = createHarness(row({ status: OutboxMessageStatus.failed }));
+		const failed = await message(OutboxMessageStatus.failed);
 
-		await harness.service.updateDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID, {
+		await queue().updateDraft(account.accountConfigId, failed.outboxMessageId, {
 			toAddresses: ["them@example.com"],
 		});
-		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
-
-		assert.equal(harness.status(), OutboxMessageStatus.queued);
-		assert.equal(harness.enqueued.length, 1);
-	});
-
-	it("accepts the edit on a `blocked` row too — Send already does", async () => {
-		const harness = createHarness(row({ status: OutboxMessageStatus.blocked }));
-
-		await harness.service.updateDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID, {
-			subject: "Invoice, corrected",
-		});
+		await queue().send(account.accountConfigId, failed.outboxMessageId);
 
-		assert.equal(applied(harness).at(0)?.status, OutboxMessageStatus.draft);
+		assert.equal(
+			(await current(failed.outboxMessageId)).status,
+			OutboxMessageStatus.queued,
+		);
+		assert.equal(enqueued.length, 1);
 	});
 
-	it("writes no status on a row that is already a draft", async () => {
-		const harness = createHarness(row({}));
+	it("accepts the edit on a blocked row too", async () => {
+		const blocked = await message(OutboxMessageStatus.blocked);
 
-		await harness.service.updateDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID, {
-			subject: "Invoice, corrected",
-		});
+		const updated = await queue().updateDraft(
+			account.accountConfigId,
+			blocked.outboxMessageId,
+			{ subject: "Invoice, corrected" },
+		);
 
-		assert.deepEqual(applied(harness), [{ subject: "Invoice, corrected" }]);
+		assert.equal(updated.status, OutboxMessageStatus.draft);
 	});
 });
 
 describe("a message that moves while the request is deciding", () => {
-	it("refuses the edit rather than pulling a queued row back to `draft`", async () => {
-		// The send this loses to has an event on the wire, and `draft` is inside
-		// the fence that event has to pass.
-		const harness = createHarness(row({ status: OutboxMessageStatus.failed }), {
-			movesOnRead: OutboxMessageStatus.queued,
-		});
+	it("refuses the edit rather than pulling a queued row back to draft", async () => {
+		const failed = await message(OutboxMessageStatus.failed);
+		beforeNext(store.outboxMessage, "updateIfStatus", () =>
+			store.outboxMessage.updateStatus(
+				account.accountConfigId,
+				failed.outboxMessageId,
+				OutboxMessageStatus.queued,
+			),
+		);
 
 		await assert.rejects(
-			() =>
-				harness.service.updateDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID, {
-					toAddresses: ["them@example.com"],
-				}),
-			(error: unknown) => {
-				assert.ok(error instanceof ConflictError);
-				assert.equal(error.statusCode, 409);
-				return true;
-			},
+			queue().updateDraft(account.accountConfigId, failed.outboxMessageId, {
+				toAddresses: ["them@example.com"],
+			}),
+			isConflict,
 		);
 
-		assert.equal(harness.status(), OutboxMessageStatus.queued);
+		assert.equal(
+			(await current(failed.outboxMessageId)).status,
+			OutboxMessageStatus.queued,
+		);
 	});
 
 	it("refuses the second of two sends racing the same row", async () => {
-		const harness = createHarness(row({}), {
-			movesOnRead: OutboxMessageStatus.sending,
-		});
+		const draft = await message(OutboxMessageStatus.draft);
+		beforeNext(store.outboxMessage, "updateIfStatus", () =>
+			store.outboxMessage.updateStatus(
+				account.accountConfigId,
+				draft.outboxMessageId,
+				OutboxMessageStatus.sending,
+			),
+		);
 
 		await assert.rejects(
-			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
-			(error: unknown) => {
-				assert.ok(error instanceof ConflictError);
-				return true;
-			},
+			queue().send(account.accountConfigId, draft.outboxMessageId),
+			isConflict,
 		);
-
-		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
+		assert.deepEqual(enqueued, []);
 	});
 });
 
@@ -349,22 +281,19 @@ describe("a message that is not the user's to edit", () => {
 		OutboxMessageStatus.sent,
 		OutboxMessageStatus.unfiled,
 	]) {
-		it(`refuses the edit of a \`${status}\` row`, async () => {
-			const harness = createHarness(row({ status }));
+		it(`refuses the edit of a ${status} row`, async () => {
+			const row = await message(status);
 
 			await assert.rejects(
-				() =>
-					harness.service.updateDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID, {
-						toAddresses: ["them@example.com"],
-					}),
-				(error: unknown) => {
-					assert.ok(error instanceof ConflictError);
-					assert.equal(error.statusCode, 409);
-					return true;
-				},
+				queue().updateDraft(account.accountConfigId, row.outboxMessageId, {
+					toAddresses: ["them@example.com"],
+				}),
+				isConflict,
 			);
 
-			assert.deepEqual(harness.writes, []);
+			assert.deepEqual((await current(row.outboxMessageId)).toAddresses, [
+				"typo@exmaple.com",
+			]);
 		});
 	}
 });

package/src/outbox-queue.test.ts

@@ -289,3 +289,27 @@ describe("OutboxQueueService and an account with mail off", () => {
 		assert.equal(harness.enqueued.length, 1);
 	});
 });
+
+describe("OutboxQueueService and a reply's threading headers", () => {
+	it("stores the parent's ids bare however they were bracketed", async () => {
+		const { service } = createHarness(draft({}));
+
+		const outbox = await service.createDraft(
+			sendInput({
+				toAddresses: ["them@example.com"],
+				inReplyTo: "<parent@example.com>",
+				references: [
+					"<<root@example.com>>",
+					"parent@example.com",
+					"<parent@example.com>",
+				],
+			}),
+		);
+
+		assert.equal(outbox.inReplyTo, "parent@example.com");
+		assert.deepEqual(outbox.references, [
+			"root@example.com",
+			"parent@example.com",
+		]);
+	});
+});

package/src/outbox-queue.ts

@@ -10,6 +10,7 @@ import {
 	ConflictError,
 	MailSyncOffError,
 } from "@remit/data-ports/errors";
+import { bareMessageId } from "@remit/data-ports/id";
 import { AccountService, OutboxMessageStatus } from "@remit/domain-enums";
 import { createQueueProducer } from "@remit/sqs-client/producer";
 import type { OutboxAttachmentService } from "./outbox-attachment.js";
@@ -69,6 +70,27 @@ export interface UpdateDraftInput {
 	references?: string[];
 }
 
+const MAX_REFERENCES = 21;
+
+const capReferences = (ids: string[]): string[] =>
+	ids.length <= MAX_REFERENCES
+		? ids
+		: [ids[0], ...ids.slice(ids.length - (MAX_REFERENCES - 1))];
+
+const bareThreadingHeaders = (input: {
+	inReplyTo?: string;
+	references?: string[];
+}): { inReplyTo?: string; references?: string[] } => ({
+	...(input.inReplyTo !== undefined && {
+		inReplyTo: bareMessageId(input.inReplyTo),
+	}),
+	...(input.references !== undefined && {
+		references: capReferences([
+			...new Set(input.references.map(bareMessageId).filter((id) => id !== "")),
+		]),
+	}),
+});
+
 /**
  * Nobody to send to. `@minItems(1)` on the create input is the only thing that
  * has ever stood between a zero-recipient message and nodemailer, which refuses
@@ -184,8 +206,7 @@ export class OutboxQueueService {
 			subject: input.subject,
 			textBody: input.textBody,
 			htmlBody: input.htmlBody,
-			inReplyTo: input.inReplyTo,
-			references: input.references,
+			...bareThreadingHeaders(input),
 			messageIdValue,
 			status: OutboxMessageStatus.draft,
 		});
@@ -244,10 +265,7 @@ export class OutboxQueueService {
 				...(input.subject !== undefined && { subject: input.subject }),
 				...(input.textBody !== undefined && { textBody: input.textBody }),
 				...(input.htmlBody !== undefined && { htmlBody: input.htmlBody }),
-				...(input.inReplyTo !== undefined && { inReplyTo: input.inReplyTo }),
-				...(input.references !== undefined && {
-					references: input.references,
-				}),
+				...bareThreadingHeaders(input),
 			},
 		);
 		if (!updated) throw new ConflictError(MOVED_WHILE_EDITING_MESSAGE);
@@ -369,8 +387,7 @@ export class OutboxQueueService {
 			subject: input.subject,
 			textBody: input.textBody,
 			htmlBody: input.htmlBody,
-			inReplyTo: input.inReplyTo,
-			references: input.references,
+			...bareThreadingHeaders(input),
 			messageIdValue,
 			status: OutboxMessageStatus.queued,
 		});