@remit/mailbox-service 0.0.112 → 0.0.113

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

@@ -1,299 +0,0 @@
-import assert from "node:assert/strict";
-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 { 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 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 message = (status: OutboxMessageItem["status"]) =>
-	store.outboxMessage.create({
-		accountId: account.accountId,
-		accountConfigId: account.accountConfigId,
-		fromAddress: "me@example.com",
-		toAddresses: ["typo@exmaple.com"],
-		messageIdValue: "<m1@example.com>",
-		subject: "Invoice",
-		textBody: "Attached.",
-		status,
-	});
-
-const createInput = () => ({
-	accountId: account.accountId,
-	accountConfigId: account.accountConfigId,
-	fromAddress: "me@example.com",
-	toAddresses: ["them@example.com"],
-	subject: "Invoice",
-	textBody: "Attached.",
-});
-
-const current = (outboxMessageId: string) =>
-	store.outboxMessage.get(account.accountConfigId, outboxMessageId);
-
-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(
-			queue().createAndSend(createInput()),
-			/SQS unavailable/,
-		);
-
-		const [row] = await all();
-		assert.equal(row.status, OutboxMessageStatus.failed);
-		assert.match(
-			String(row.lastError),
-			/could not be handed to the outgoing queue/,
-		);
-	});
-
-	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(
-			queue().send(account.accountConfigId, draft.outboxMessageId),
-		);
-
-		assert.equal(
-			(await current(draft.outboxMessageId)).status,
-			OutboxMessageStatus.failed,
-		);
-	});
-
-	it("returns a blocked row to blocked", async () => {
-		const blocked = await message(OutboxMessageStatus.blocked);
-		enqueueFails = new Error("SQS unavailable");
-
-		await assert.rejects(
-			queue().send(account.accountConfigId, blocked.outboxMessageId),
-		);
-
-		assert.equal(
-			(await current(blocked.outboxMessageId)).status,
-			OutboxMessageStatus.blocked,
-		);
-	});
-
-	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(
-			queue().send(account.accountConfigId, draft.outboxMessageId),
-		);
-
-		assert.equal(
-			(await current(draft.outboxMessageId)).status,
-			OutboxMessageStatus.sending,
-		);
-	});
-
-	it("keeps the row queued when the enqueue succeeds", async () => {
-		await queue().createAndSend(createInput());
-
-		const [row] = await all();
-		assert.equal(row.status, OutboxMessageStatus.queued);
-		assert.equal(enqueued.length, 1);
-	});
-});
-
-describe("a row the worker settled", () => {
-	it("is sendable again from failed, and discardable", async () => {
-		const failed = await message(OutboxMessageStatus.failed);
-
-		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("is discardable but never sendable from unfiled", async () => {
-		const unfiled = await message(OutboxMessageStatus.unfiled);
-
-		await assert.rejects(
-			queue().send(account.accountConfigId, unfiled.outboxMessageId),
-			/cannot be sent again/,
-		);
-		assert.deepEqual(enqueued, []);
-
-		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, keeps the content and returns the row to draft", async () => {
-		const failed = await message(OutboxMessageStatus.failed);
-
-		const updated = await queue().updateDraft(
-			account.accountConfigId,
-			failed.outboxMessageId,
-			{ toAddresses: ["them@example.com"] },
-		);
-
-		assert.equal(updated.status, OutboxMessageStatus.draft);
-		assert.deepEqual(updated.toAddresses, ["them@example.com"]);
-		assert.equal(updated.subject, "Invoice");
-	});
-
-	it("sends the corrected message", async () => {
-		const failed = await message(OutboxMessageStatus.failed);
-
-		await queue().updateDraft(account.accountConfigId, failed.outboxMessageId, {
-			toAddresses: ["them@example.com"],
-		});
-		await queue().send(account.accountConfigId, failed.outboxMessageId);
-
-		assert.equal(
-			(await current(failed.outboxMessageId)).status,
-			OutboxMessageStatus.queued,
-		);
-		assert.equal(enqueued.length, 1);
-	});
-
-	it("accepts the edit on a blocked row too", async () => {
-		const blocked = await message(OutboxMessageStatus.blocked);
-
-		const updated = await queue().updateDraft(
-			account.accountConfigId,
-			blocked.outboxMessageId,
-			{ 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 () => {
-		const failed = await message(OutboxMessageStatus.failed);
-		beforeNext(store.outboxMessage, "updateIfStatus", () =>
-			store.outboxMessage.updateStatus(
-				account.accountConfigId,
-				failed.outboxMessageId,
-				OutboxMessageStatus.queued,
-			),
-		);
-
-		await assert.rejects(
-			queue().updateDraft(account.accountConfigId, failed.outboxMessageId, {
-				toAddresses: ["them@example.com"],
-			}),
-			isConflict,
-		);
-
-		assert.equal(
-			(await current(failed.outboxMessageId)).status,
-			OutboxMessageStatus.queued,
-		);
-	});
-
-	it("refuses the second of two sends racing the same row", async () => {
-		const draft = await message(OutboxMessageStatus.draft);
-		beforeNext(store.outboxMessage, "updateIfStatus", () =>
-			store.outboxMessage.updateStatus(
-				account.accountConfigId,
-				draft.outboxMessageId,
-				OutboxMessageStatus.sending,
-			),
-		);
-
-		await assert.rejects(
-			queue().send(account.accountConfigId, draft.outboxMessageId),
-			isConflict,
-		);
-		assert.deepEqual(enqueued, []);
-	});
-});
-
-describe("a message that is not the user's to edit", () => {
-	for (const status of [
-		OutboxMessageStatus.queued,
-		OutboxMessageStatus.sending,
-		OutboxMessageStatus.sent,
-		OutboxMessageStatus.unfiled,
-	]) {
-		it(`refuses the edit of a ${status} row`, async () => {
-			const row = await message(status);
-
-			await assert.rejects(
-				queue().updateDraft(account.accountConfigId, row.outboxMessageId, {
-					toAddresses: ["them@example.com"],
-				}),
-				isConflict,
-			);
-
-			assert.deepEqual((await current(row.outboxMessageId)).toAddresses, [
-				"typo@exmaple.com",
-			]);
-		});
-	}
-});

package/src/outbox-queue.test.ts

@@ -1,315 +0,0 @@
-/**
- * A message with nobody to send to must be refused where the person who pressed
- * Send can see the refusal.
- *
- * `@minItems(1)` on `CreateOutboxMessageInput.toAddresses` was the only check
- * anywhere on the path, and neither route into the queue passes it: `send`
- * takes a stored draft, which the update endpoint will happily strip every
- * address off, and `createAndSend` reaches nodemailer with whatever it was
- * handed. Nodemailer refuses an empty envelope inside the SMTP worker, so the
- * message dies in the DLQ and the composer reports a send that went nowhere.
- */
-
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type {
-	IAccountRepository,
-	IOutboxMessageRepository,
-	OutboxAttachmentItem,
-	OutboxMessageItem,
-} from "@remit/data-ports";
-import { BadRequestError, MailSyncOffError } from "@remit/data-ports/errors";
-import { OutboxMessageStatus } from "@remit/domain-enums";
-import type { OutboxAttachmentService } from "./outbox-attachment.js";
-import { OutboxQueueService } from "./outbox-queue.js";
-
-const ACCOUNT_CONFIG_ID = "cfg-1";
-const ACCOUNT_ID = "acc-1";
-const OUTBOX_MESSAGE_ID = "ob-1";
-
-const draft = (overrides: Partial<OutboxMessageItem>): OutboxMessageItem =>
-	({
-		outboxMessageId: OUTBOX_MESSAGE_ID,
-		accountId: ACCOUNT_ID,
-		accountConfigId: ACCOUNT_CONFIG_ID,
-		fromAddress: "me@example.com",
-		toAddresses: ["them@example.com"],
-		ccAddresses: [],
-		bccAddresses: [],
-		references: [],
-		messageIdValue: "<m1@example.com>",
-		status: OutboxMessageStatus.draft,
-		createdAt: 0,
-		updatedAt: 0,
-		...overrides,
-	}) as OutboxMessageItem;
-
-interface Harness {
-	service: OutboxQueueService;
-	enqueued: string[];
-	created: number;
-	statusWrites: string[];
-}
-
-const createHarness = (
-	stored: OutboxMessageItem,
-	attachments: OutboxAttachmentItem[] = [],
-	lateAttachments: OutboxAttachmentItem[] = [],
-	syncedServices: string[] = ["Mail"],
-): Harness => {
-	let unfinishedChecks = 0;
-	const harness: Harness = {
-		service: undefined as unknown as OutboxQueueService,
-		enqueued: [],
-		created: 0,
-		statusWrites: [],
-	};
-
-	const outboxMessageService = {
-		get: async () => stored,
-		create: async (input: Record<string, unknown>) => {
-			harness.created += 1;
-			return draft(input as Partial<OutboxMessageItem>);
-		},
-		updateStatus: async (
-			_configId: string,
-			_id: string,
-			status: OutboxMessageItem["status"],
-		) => {
-			harness.statusWrites.push(status);
-			return draft({ status });
-		},
-		updateIfStatus: async (
-			_configId: string,
-			_id: string,
-			_expected: OutboxMessageItem["status"],
-			input: { status?: OutboxMessageItem["status"] },
-		) => {
-			if (input.status) harness.statusWrites.push(input.status);
-			return draft(input as Partial<OutboxMessageItem>);
-		},
-	} as unknown as IOutboxMessageRepository;
-
-	harness.service = new OutboxQueueService({
-		outboxMessageService,
-		outboxAttachmentService: {
-			unfinishedUpload: async () => {
-				unfinishedChecks += 1;
-				const held = unfinishedChecks === 1 ? attachments : lateAttachments;
-				return held.find((item) => item.state !== "Stored");
-			},
-		} as unknown as OutboxAttachmentService,
-		accountService: {
-			get: async () => ({ syncedServices }),
-		} as unknown as IAccountRepository,
-		sqsSmtpQueueUrl: "http://localhost/queue",
-		sqsClient: {
-			send: async (command: { input: { MessageBody: string } }) => {
-				harness.enqueued.push(command.input.MessageBody);
-				return {};
-			},
-		} as never,
-	});
-
-	return harness;
-};
-
-const pendingFile: OutboxAttachmentItem = {
-	outboxAttachmentId: "att-late",
-	outboxMessageId: OUTBOX_MESSAGE_ID,
-	accountId: ACCOUNT_ID,
-	accountConfigId: ACCOUNT_CONFIG_ID,
-	filename: "report.pdf",
-	contentType: "application/pdf",
-	sizeBytes: 10,
-	state: "Pending",
-	storageKey: "k",
-	reservationExpiresAt: Number.MAX_SAFE_INTEGER,
-	createdAt: 0,
-	updatedAt: 0,
-};
-
-const sendInput = (overrides: Record<string, unknown>) => ({
-	accountId: ACCOUNT_ID,
-	accountConfigId: ACCOUNT_CONFIG_ID,
-	fromAddress: "me@example.com",
-	toAddresses: [] as string[],
-	...overrides,
-});
-
-describe("OutboxQueueService and a message with nowhere to go", () => {
-	it("refuses to queue a stored draft that has lost every address", async () => {
-		const harness = createHarness(
-			draft({ toAddresses: [], ccAddresses: [], bccAddresses: [] }),
-		);
-
-		await assert.rejects(
-			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
-			(error: unknown) => {
-				assert.ok(error instanceof BadRequestError);
-				assert.equal(error.statusCode, 400);
-				return true;
-			},
-		);
-
-		assert.deepEqual(harness.statusWrites, [], "it stayed a draft");
-		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
-	});
-
-	it("puts the draft back when a reservation lands between the check and the queue", async () => {
-		const harness = createHarness(draft({}), [], [pendingFile]);
-
-		await assert.rejects(
-			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
-			(error: unknown) => {
-				assert.ok(error instanceof BadRequestError);
-				assert.match(error.message, /"report\.pdf" has not finished uploading/);
-				return true;
-			},
-		);
-
-		assert.deepEqual(harness.statusWrites, [
-			OutboxMessageStatus.queued,
-			OutboxMessageStatus.draft,
-		]);
-		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
-	});
-
-	it("refuses to queue a draft with a file still uploading, and names the file", async () => {
-		const harness = createHarness(draft({}), [
-			{
-				outboxAttachmentId: "att-1",
-				outboxMessageId: OUTBOX_MESSAGE_ID,
-				accountId: ACCOUNT_ID,
-				accountConfigId: ACCOUNT_CONFIG_ID,
-				filename: "report.pdf",
-				contentType: "application/pdf",
-				sizeBytes: 10,
-				state: "Pending",
-				storageKey: "k",
-				reservationExpiresAt: Number.MAX_SAFE_INTEGER,
-				createdAt: 0,
-				updatedAt: 0,
-			},
-		]);
-
-		await assert.rejects(
-			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
-			(error: unknown) => {
-				assert.ok(error instanceof BadRequestError);
-				assert.match(error.message, /"report\.pdf" has not finished uploading/);
-				return true;
-			},
-		);
-
-		assert.deepEqual(harness.statusWrites, [], "it stayed a draft");
-		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
-	});
-
-	it("queues a draft addressed only in Bcc — that envelope is real", async () => {
-		const harness = createHarness(
-			draft({ toAddresses: [], bccAddresses: ["them@example.com"] }),
-		);
-
-		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
-
-		assert.deepEqual(harness.statusWrites, [OutboxMessageStatus.queued]);
-		assert.equal(harness.enqueued.length, 1);
-	});
-
-	it("refuses a send-immediately create with no addresses, before writing a row", async () => {
-		const harness = createHarness(draft({}));
-
-		await assert.rejects(
-			() => harness.service.createAndSend(sendInput({})),
-			(error: unknown) => {
-				assert.ok(error instanceof BadRequestError);
-				assert.equal(error.statusCode, 400);
-				return true;
-			},
-		);
-
-		assert.equal(harness.created, 0, "no queued row was left behind");
-		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
-	});
-
-	it("still creates and queues a send-immediately message that has a recipient", async () => {
-		const harness = createHarness(draft({}));
-
-		await harness.service.createAndSend(
-			sendInput({ toAddresses: ["them@example.com"] }),
-		);
-
-		assert.equal(harness.created, 1);
-		assert.equal(harness.enqueued.length, 1);
-	});
-});
-
-describe("OutboxQueueService and an account with mail off", () => {
-	const refusesWithTheFix = (error: unknown): boolean => {
-		assert.ok(error instanceof MailSyncOffError);
-		assert.equal(error.statusCode, 400);
-		assert.equal(error.publicApiError?.code, "mail_sync_off");
-		assert.match(error.message, /Turn Mail back on .* in Settings/);
-		return true;
-	};
-
-	it("refuses to queue a stored draft and leaves it a draft", async () => {
-		const harness = createHarness(draft({}), [], [], ["Calendar"]);
-
-		await assert.rejects(
-			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
-			refusesWithTheFix,
-		);
-
-		assert.deepEqual(harness.statusWrites, []);
-		assert.deepEqual(harness.enqueued, []);
-	});
-
-	it("refuses a send-immediately create before writing a row", async () => {
-		const harness = createHarness(draft({}), [], [], ["Calendar"]);
-
-		await assert.rejects(
-			() =>
-				harness.service.createAndSend(
-					sendInput({ toAddresses: ["them@example.com"] }),
-				),
-			refusesWithTheFix,
-		);
-
-		assert.equal(harness.created, 0);
-		assert.deepEqual(harness.enqueued, []);
-	});
-
-	it("sends from an account syncing mail and calendar", async () => {
-		const harness = createHarness(draft({}), [], [], ["Mail", "Calendar"]);
-
-		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
-
-		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",
-		]);
-	});
-});