@remit/mailbox-service 0.0.111 → 0.0.113

package/src/mailbox-cursor.test.ts

@@ -1,249 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it, mock } from "node:test";
-import type { IMailboxRepository, MailboxItem } from "@remit/data-ports";
-import { MailboxCursorState } from "@remit/domain-enums";
-import {
-	guardConnectionCursor,
-	guardMailboxCursor,
-	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);
-	});
-
-	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,
-		);
-
-		assert.deepEqual(result, { ok: true });
-	});
-
-	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,
-		);
-
-		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 },
-		]);
-	});
-
-	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,
-		);
-
-		assert.deepEqual(result, { 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)",
-		);
-	});
-
-	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);
-	});
-});
-
-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 result = await guarded.openBox("INBOX", false);
-
-		assert.deepEqual(result, fakeBoxStatus(100));
-		assert.equal(openBox.mock.calls.length, 1);
-		assert.equal(update.mock.calls.length, 0);
-	});
-
-	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 },
-		);
-
-		await assert.rejects(
-			() => guarded.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 },
-		);
-
-		await assert.rejects(
-			() => guarded.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",
-		);
-	});
-
-	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", () => {
-	it("is false for undefined and normal", () => {
-		assert.equal(isCursorRebuildNeeded(undefined), false);
-		assert.equal(isCursorRebuildNeeded(MailboxCursorState.normal), false);
-	});
-
-	it("is true for cursor_invalid and rebuilding", () => {
-		assert.equal(
-			isCursorRebuildNeeded(MailboxCursorState.cursor_invalid),
-			true,
-		);
-		assert.equal(isCursorRebuildNeeded(MailboxCursorState.rebuilding), true);
-	});
-});

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

@@ -1,246 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { IMailboxRepository, 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",
-	});
-	(
-		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",
-		);
-	});
-
-	it("accepts a retry from a failed delete", async () => {
-		const { repo, byId } = store([
-			row({ syncStatus: MailboxSyncStatus.failed }),
-		]);
-		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);
-	});
-
-	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);
-
-		await assert.rejects(
-			service.deleteMailbox("mbx-1", "acc-1"),
-			(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");
-	});
-
-	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);
-
-		await assert.rejects(
-			service.deleteMailbox("mbx-1", "acc-1"),
-			(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, []);
-	});
-
-	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),
-		);
-
-		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);
-	});
-
-	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"),
-			(error: unknown) => (error as Error).name === "NotFoundError",
-		);
-	});
-});