@remit/mailbox-service 0.0.111 → 0.0.112

package/src/mailbox-cursor.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
-import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { AccountItem, MailboxItem } from "@remit/data-ports";
 import { MailboxCursorState } from "@remit/domain-enums";
 import {
 	guardConnectionCursor,
@@ -8,229 +8,121 @@ import {
 	isCursorRebuildNeeded,
 	MailboxCursorPausedError,
 } from "./mailbox-cursor.js";
-import type { IImapConnection, ImapBoxStatus } from "./types.js";
-
-const mailboxId = "mbx-1";
-const accountId = "acc-1";
-
-const baseMailbox: Pick<MailboxItem, "mailboxId" | "uidValidity"> & {
-	cursorState: MailboxItem["cursorState"] | undefined;
-} = {
-	mailboxId,
-	uidValidity: 100,
-	// A pre-migration row genuinely lacks this attribute at runtime despite the
-	// type saying it's total — see mailbox-cursor.ts for why `undefined` is
-	// accepted here.
-	cursorState: undefined,
-};
-
-describe("guardMailboxCursor", () => {
-	it("is ok and writes nothing when the served UIDVALIDITY matches the stored value", async () => {
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = {
-			update,
-		} as unknown as Pick<IMailboxRepository, "update">;
-
-		const result = await guardMailboxCursor(
-			{ mailboxService },
-			accountId,
-			baseMailbox,
-			100,
-		);
-
-		assert.deepEqual(result, { ok: true });
-		assert.equal(update.mock.calls.length, 0);
+import { eml, FakeImapServer } from "./test-helpers/fake-imap.js";
+import {
+	openStore,
+	type Store,
+	seedAccount,
+	seedMailbox,
+} from "./test-helpers/test-store.js";
+
+let store: Store;
+let imap: FakeImapServer;
+let account: AccountItem;
+let inbox: MailboxItem;
+
+beforeEach(async () => {
+	store = await openStore();
+	imap = new FakeImapServer();
+	imap.addFolder("INBOX", { uidValidity: 100 });
+	account = await seedAccount(store);
+	inbox = await seedMailbox(store, account, "INBOX", {
+		overrides: { uidValidity: 100 },
 	});
+});
 
-	it("treats an absent cursorState as normal", async () => {
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const result = await guardMailboxCursor(
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, cursorState: undefined },
-			100,
-		);
+afterEach(() => store.close());
 
-		assert.deepEqual(result, { ok: true });
-	});
+const stored = () => store.mailbox.get(account.accountId, inbox.mailboxId);
 
-	it("trips cursor_invalid and persists it when the served UIDVALIDITY disagrees", async () => {
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const result = await guardMailboxCursor(
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, uidValidity: 100 },
-			200,
-		);
+const pause = (cursorState: MailboxItem["cursorState"]) =>
+	store.mailbox.update(account.accountId, inbox.mailboxId, { cursorState });
 
-		assert.deepEqual(result, { ok: false, state: "cursor_invalid" });
-		assert.equal(update.mock.calls.length, 1);
-		assert.deepEqual(update.mock.calls[0].arguments, [
-			accountId,
-			mailboxId,
-			{ cursorState: MailboxCursorState.cursor_invalid },
-		]);
-	});
+const guard = async (served: number) =>
+	guardMailboxCursor(
+		{ mailboxService: store.mailbox },
+		account.accountId,
+		await stored(),
+		served,
+	);
 
-	it("short-circuits without a write when already cursor_invalid, even if UIDVALIDITY now matches", async () => {
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const result = await guardMailboxCursor(
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, cursorState: MailboxCursorState.cursor_invalid },
-			100,
-		);
+describe("guardMailboxCursor", () => {
+	it("passes a mailbox whose served UIDVALIDITY matches", async () => {
+		assert.deepEqual(await guard(100), { ok: true });
+		assert.equal((await stored()).cursorState, MailboxCursorState.normal);
+	});
 
-		assert.deepEqual(result, { ok: false, state: "cursor_invalid" });
+	it("trips and persists cursor_invalid when the served UIDVALIDITY disagrees", async () => {
+		assert.deepEqual(await guard(200), { ok: false, state: "cursor_invalid" });
 		assert.equal(
-			update.mock.calls.length,
-			0,
-			"paused mailboxes must not be re-tripped on every call (frugal — invariant 6)",
+			(await stored()).cursorState,
+			MailboxCursorState.cursor_invalid,
 		);
 	});
 
-	it("short-circuits without a write when rebuilding", async () => {
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const result = await guardMailboxCursor(
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, cursorState: MailboxCursorState.rebuilding },
-			999,
-		);
-
-		assert.deepEqual(result, { ok: false, state: "rebuilding" });
-		assert.equal(update.mock.calls.length, 0);
-	});
+	for (const state of [
+		MailboxCursorState.cursor_invalid,
+		MailboxCursorState.rebuilding,
+	]) {
+		it(`stays paused while ${state}, whatever the server serves`, async () => {
+			await pause(state);
+
+			assert.deepEqual(await guard(100), { ok: false, state });
+			assert.equal((await stored()).cursorState, state);
+		});
+	}
 });
 
 describe("guardConnectionCursor", () => {
-	const fakeBoxStatus = (uidvalidity: number): ImapBoxStatus =>
-		({
-			uidvalidity,
-		}) as unknown as ImapBoxStatus;
-
-	it("delegates to the real openBox and returns normally when normal and matching", async () => {
-		const openBox = mock.fn(async () => fakeBoxStatus(100));
-		const connection = { openBox } as unknown as IImapConnection;
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const guarded = guardConnectionCursor(
-			connection,
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, uidValidity: 100 },
+	const guarded = async () =>
+		guardConnectionCursor(
+			imap.connection(),
+			{ mailboxService: store.mailbox },
+			account.accountId,
+			await stored(),
 		);
 
-		const result = await guarded.openBox("INBOX", false);
+	it("opens the box and passes other calls through when the cursor holds", async () => {
+		imap.deliver("INBOX", eml({}));
+		const connection = await guarded();
 
-		assert.deepEqual(result, fakeBoxStatus(100));
-		assert.equal(openBox.mock.calls.length, 1);
-		assert.equal(update.mock.calls.length, 0);
-	});
+		const box = await connection.openBox("INBOX");
+		const rows = await connection.fetchMessages([1]);
 
-	it("throws MailboxCursorPausedError and never calls the real openBox when already paused", async () => {
-		const openBox = mock.fn(async () => fakeBoxStatus(100));
-		const connection = { openBox } as unknown as IImapConnection;
-		const mailboxService = {
-			update: mock.fn(async () => ({}) as MailboxItem),
-		} as unknown as Pick<IMailboxRepository, "update">;
-
-		const guarded = guardConnectionCursor(
-			connection,
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, cursorState: MailboxCursorState.cursor_invalid },
+		assert.equal(box.uidvalidity, 100);
+		assert.deepEqual(
+			rows.map((row) => row.uid),
+			[1],
 		);
+	});
+
+	it("refuses to open a mailbox already paused", async () => {
+		await pause(MailboxCursorState.cursor_invalid);
+		const connection = await guarded();
 
 		await assert.rejects(
-			() => guarded.openBox("INBOX"),
+			connection.openBox("INBOX"),
 			(err: unknown) =>
 				err instanceof MailboxCursorPausedError &&
 				err.state === "cursor_invalid",
 		);
-		assert.equal(
-			openBox.mock.calls.length,
-			0,
-			"a mailbox already known paused must not touch the network (frugal — invariant 6)",
-		);
 	});
 
-	it("trips and throws MailboxCursorPausedError when the served UIDVALIDITY disagrees", async () => {
-		const openBox = mock.fn(async () => fakeBoxStatus(200));
-		const connection = { openBox } as unknown as IImapConnection;
-		const update = mock.fn(async () => ({}) as MailboxItem);
-		const mailboxService = { update } as unknown as Pick<
-			IMailboxRepository,
-			"update"
-		>;
-
-		const guarded = guardConnectionCursor(
-			connection,
-			{ mailboxService },
-			accountId,
-			{ ...baseMailbox, uidValidity: 100 },
-		);
+	it("trips the mailbox and refuses when the server renumbered it", async () => {
+		const connection = await guarded();
+		imap.renumber("INBOX", 200);
 
 		await assert.rejects(
-			() => guarded.openBox("INBOX"),
+			connection.openBox("INBOX"),
 			(err: unknown) =>
 				err instanceof MailboxCursorPausedError &&
 				err.state === "cursor_invalid",
 		);
 		assert.equal(
-			openBox.mock.calls.length,
-			1,
-			"the real openBox must run once to learn the served UIDVALIDITY",
-		);
-		assert.equal(
-			update.mock.calls.length,
-			1,
-			"the mismatch must trip the mailbox",
+			(await stored()).cursorState,
+			MailboxCursorState.cursor_invalid,
 		);
 	});
-
-	it("passes other methods through untouched (e.g. fetchMessages)", async () => {
-		const fetchMessages = mock.fn(async () => []);
-		const connection = {
-			openBox: async () => fakeBoxStatus(100),
-			fetchMessages,
-		} as unknown as IImapConnection;
-
-		const guarded = guardConnectionCursor(
-			connection,
-			{ mailboxService: { update: async () => ({}) as MailboxItem } },
-			accountId,
-			{ ...baseMailbox, uidValidity: 100 },
-		);
-
-		await guarded.fetchMessages([1, 2, 3]);
-		assert.equal(fetchMessages.mock.calls.length, 1);
-		assert.deepEqual(fetchMessages.mock.calls[0].arguments, [[1, 2, 3]]);
-	});
 });
 
 describe("isCursorRebuildNeeded", () => {

package/src/mailbox-delete-intent.test.ts

@@ -1,245 +1,118 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import type { AccountItem, MailboxItem } from "@remit/data-ports";
 import { MailboxSyncStatus } from "@remit/domain-enums";
 import { MailboxManagementService } from "./mailbox-management.js";
 import { MailboxQueueService } from "./mailbox-queue.js";
-import type { IImapConnection } from "./types.js";
-
-const row = (over: Partial<MailboxItem> = {}): MailboxItem =>
-	({
-		mailboxId: "mbx-1",
-		accountId: "acc-1",
-		fullPath: "Receipts",
-		hierarchyDelimiter: "/",
-		syncStatus: MailboxSyncStatus.synced,
-		...over,
-	}) as MailboxItem;
-
-const store = (rows: MailboxItem[]) => {
-	const byId = new Map(rows.map((r) => [r.mailboxId, { ...r }]));
-	const removed: string[] = [];
-
-	const repo: Pick<
-		IMailboxRepository,
-		"get" | "transition" | "findByPathPrefix" | "deleteMailboxWithMail"
-	> = {
-		get: (async (_accountId: string, mailboxId: string) => {
-			const found = byId.get(mailboxId as string);
-			if (!found) {
-				throw Object.assign(new Error(`Mailbox not found: ${mailboxId}`), {
-					name: "NotFoundError",
-				});
-			}
-			return found;
-		}) as IMailboxRepository["get"],
-		findByPathPrefix: async () => [],
-		transition: async (_accountId, mailboxId, intent) => {
-			const current = byId.get(mailboxId);
-			if (!current) return null;
-			if (!intent.from.includes(current.syncStatus)) return null;
-			const next = { ...current, syncStatus: intent.to } as MailboxItem;
-			byId.set(mailboxId, next);
-			return next;
-		},
-		deleteMailboxWithMail: async (_accountId, mailboxId) => {
-			removed.push(mailboxId);
-			byId.delete(mailboxId);
-		},
-	};
-
-	return { repo: repo as IMailboxRepository, byId, removed };
-};
-
-const queueOver = (repo: IMailboxRepository) => {
-	const sent: string[] = [];
-	const service = new MailboxQueueService({
-		mailboxService: repo,
-		sqsQueueUrl: "http://localhost:4566/000000000000/mailbox",
+import {
+	captureQueue,
+	openStore,
+	type QueueCapture,
+	type QueuedEvent,
+	type Store,
+	seedAccount,
+	seedMailbox,
+} from "./test-helpers/test-store.js";
+
+let store: Store;
+let capture: QueueCapture;
+let queue: QueuedEvent[];
+let account: AccountItem;
+let receipts: MailboxItem;
+
+beforeEach(async () => {
+	capture = captureQueue();
+	queue = capture.sent;
+	store = await openStore();
+	account = await seedAccount(store);
+	receipts = await seedMailbox(store, account, "Receipts");
+});
+
+afterEach(async () => {
+	capture.restore();
+	await store.close();
+});
+
+const markAs = (syncStatus: MailboxItem["syncStatus"], pendingPath?: string) =>
+	store.mailbox.transition(account.accountId, receipts.mailboxId, {
+		from: [MailboxSyncStatus.synced],
+		to: syncStatus,
+		set: pendingPath ? { pendingPath } : {},
 	});
-	(
-		service as unknown as {
-			sqs: {
-				send: (command: { input: { MessageBody: string } }) => Promise<void>;
-			};
-		}
-	).sqs = {
-		send: async (command) => {
-			sent.push(command.input.MessageBody);
-		},
-	};
-	return { service, sent };
-};
-
-describe("MailboxQueueService.deleteMailbox — the recorded intent", () => {
-	it("records `deleting` and enqueues one DELETE", async () => {
-		const { repo, byId } = store([row()]);
-		const { service, sent } = queueOver(repo);
-
-		await service.deleteMailbox("mbx-1", "acc-1");
-
-		assert.equal(byId.get("mbx-1")?.syncStatus, MailboxSyncStatus.deleting);
-		assert.equal(sent.length, 1);
-		assert.equal(
-			(JSON.parse(sent[0]) as { path: string }).path,
-			"Receipts",
-			"the event names the path the server holds",
+
+const requestDelete = () =>
+	new MailboxQueueService({
+		mailboxService: store.mailbox,
+		sqsQueueUrl: "http://localhost:4566/000000000000/mailbox",
+	}).deleteMailbox(receipts.mailboxId, account.accountId);
+
+const current = () => store.mailbox.get(account.accountId, receipts.mailboxId);
+
+const management = () => new MailboxManagementService(store.mailbox);
+
+describe("MailboxQueueService.deleteMailbox records the intent", () => {
+	it("records deleting and enqueues one DELETE naming the server's path", async () => {
+		await requestDelete();
+
+		assert.equal((await current()).syncStatus, MailboxSyncStatus.deleting);
+		assert.deepEqual(
+			queue.map((event) => event.body.path),
+			["Receipts"],
 		);
 	});
 
 	it("accepts a retry from a failed delete", async () => {
-		const { repo, byId } = store([
-			row({ syncStatus: MailboxSyncStatus.failed }),
-		]);
-		const { service, sent } = queueOver(repo);
+		await markAs(MailboxSyncStatus.failed);
 
-		await service.deleteMailbox("mbx-1", "acc-1");
+		await requestDelete();
 
-		assert.equal(byId.get("mbx-1")?.syncStatus, MailboxSyncStatus.deleting);
-		assert.equal(sent.length, 1);
+		assert.equal((await current()).syncStatus, MailboxSyncStatus.deleting);
+		assert.equal(queue.length, 1);
 	});
 
-	it("gives the loser a 409 naming the delete already in flight", async () => {
-		const { repo } = store([row({ syncStatus: MailboxSyncStatus.deleting })]);
-		const { service, sent } = queueOver(repo);
+	it("answers a second delete with a 409 and enqueues nothing", async () => {
+		await requestDelete();
 
 		await assert.rejects(
-			service.deleteMailbox("mbx-1", "acc-1"),
+			requestDelete(),
 			(error: unknown) =>
 				(error as { statusCode?: number }).statusCode === 409 &&
 				(error as Error).message ===
 					'A delete is already in progress for "Receipts".',
 		);
-		assert.equal(sent.length, 0, "the loser enqueues nothing");
+		assert.equal(queue.length, 1);
 	});
 
-	it("gives the loser a 409 naming a rename in flight", async () => {
-		const { repo } = store([
-			row({
-				syncStatus: MailboxSyncStatus.pending,
-				pendingPath: "Bonnen",
-			}),
-		]);
-		const { service } = queueOver(repo);
+	it("answers a delete during a rename with a 409 naming the rename", async () => {
+		await markAs(MailboxSyncStatus.pending, "Bonnen");
 
 		await assert.rejects(
-			service.deleteMailbox("mbx-1", "acc-1"),
+			requestDelete(),
 			(error: unknown) =>
 				(error as Error).message === 'A rename is in progress for "Receipts".',
 		);
 	});
 });
 
-describe("MailboxManagementService.syncDelete — settling the intent", () => {
-	const deleting = () =>
-		store([row({ syncStatus: MailboxSyncStatus.deleting })]);
-
-	const connection = (calls: string[]): IImapConnection =>
-		({
-			deleteMailbox: async (path: string) => {
-				calls.push(path);
-				return { path };
-			},
-		}) as unknown as IImapConnection;
-
-	it("takes the folder's mail with it, not the row alone", async () => {
-		// Removing the row alone leaves every message and thread_message row keyed
-		// to a dead mailboxId — out of every reader, and still in the search index
-		// because nothing writes the `message.removed` outbox event (D8).
-		const { repo, removed, byId } = deleting();
-		const service = new MailboxManagementService(repo);
-		const calls: string[] = [];
-
-		const result = await service.syncDelete(
-			"acc-1",
-			"mbx-1",
-			"Receipts",
-			async () => connection(calls),
-		);
-
-		assert.equal(result.success, true);
-		assert.deepEqual(calls, ["Receipts"]);
-		assert.deepEqual(removed, ["mbx-1"]);
-		assert.equal(byId.has("mbx-1"), false);
-	});
-
-	it("issues no DELETE when the row is not deleting", async () => {
-		const { repo, removed } = store([row()]);
-		const service = new MailboxManagementService(repo);
-		const calls: string[] = [];
-
-		const result = await service.syncDelete(
-			"acc-1",
-			"mbx-1",
-			"Receipts",
-			async () => connection(calls),
-		);
-
-		assert.equal(result.success, true);
-		assert.deepEqual(calls, [], "the connection is never asked");
-		assert.deepEqual(removed, []);
-	});
-
-	it("resolves when the row is already gone", async () => {
-		const { repo } = store([]);
-		const service = new MailboxManagementService(repo);
-		const calls: string[] = [];
-
-		const result = await service.syncDelete(
-			"acc-1",
-			"mbx-1",
-			"Receipts",
-			async () => connection(calls),
-		);
-
-		assert.equal(result.success, true);
-		assert.deepEqual(calls, []);
-	});
+describe("MailboxManagementService.failDelete", () => {
+	it("marks the row failed and keeps its path, with no rename target", async () => {
+		await requestDelete();
 
-	it("resumes an interrupted removal on a redelivery", async () => {
-		// The row stays `deleting` until the final commit, so a redelivery
-		// re-enters, passes the guard and continues where it stopped.
-		const { repo, removed } = deleting();
-		const service = new MailboxManagementService(repo);
-		const calls: string[] = [];
-
-		await service.settleDelete("acc-1", "mbx-1");
-		const result = await service.syncDelete(
-			"acc-1",
-			"mbx-1",
-			"Receipts",
-			async () => connection(calls),
+		await management().failDelete(
+			account.accountId,
+			receipts.mailboxId,
+			"Permission denied",
 		);
 
-		assert.equal(result.success, true);
-		assert.deepEqual(calls, [], "no second IMAP DELETE is issued");
-		assert.deepEqual(removed, ["mbx-1"]);
-	});
-});
-
-describe("MailboxManagementService.failDelete", () => {
-	it("marks the row failed, unwinding nothing", async () => {
-		// DELETE is all-or-nothing, so fullPath is still what the server holds,
-		// and no rename target is written — which is how the client tells a failed
-		// delete from a failed rename (T9).
-		const { repo, byId } = store([
-			row({ syncStatus: MailboxSyncStatus.deleting }),
-		]);
-		const service = new MailboxManagementService(repo);
-
-		await service.failDelete("acc-1", "mbx-1", "Permission denied");
-
-		assert.equal(byId.get("mbx-1")?.syncStatus, MailboxSyncStatus.failed);
-		assert.equal(byId.get("mbx-1")?.fullPath, "Receipts");
-		assert.equal(byId.get("mbx-1")?.pendingPath, undefined);
+		const failed = await current();
+		assert.equal(failed.syncStatus, MailboxSyncStatus.failed);
+		assert.equal(failed.fullPath, "Receipts");
+		assert.equal(failed.pendingPath, undefined);
 	});
 
 	it("raises a NotFoundError when the row is gone", async () => {
-		const { repo } = store([]);
-		const service = new MailboxManagementService(repo);
-
 		await assert.rejects(
-			service.failDelete("acc-1", "mbx-1", "Permission denied"),
+			management().failDelete(account.accountId, "mbx-gone", "denied"),
 			(error: unknown) => (error as Error).name === "NotFoundError",
 		);
 	});