@remit/mailbox-service 0.0.112 → 0.0.113

package/src/mailbox-cursor.test.ts

@@ -1,141 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import type { AccountItem, MailboxItem } from "@remit/data-ports";
-import { MailboxCursorState } from "@remit/domain-enums";
-import {
-	guardConnectionCursor,
-	guardMailboxCursor,
-	isCursorRebuildNeeded,
-	MailboxCursorPausedError,
-} from "./mailbox-cursor.js";
-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 },
-	});
-});
-
-afterEach(() => store.close());
-
-const stored = () => store.mailbox.get(account.accountId, inbox.mailboxId);
-
-const pause = (cursorState: MailboxItem["cursorState"]) =>
-	store.mailbox.update(account.accountId, inbox.mailboxId, { cursorState });
-
-const guard = async (served: number) =>
-	guardMailboxCursor(
-		{ mailboxService: store.mailbox },
-		account.accountId,
-		await stored(),
-		served,
-	);
-
-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);
-	});
-
-	it("trips and persists cursor_invalid when the served UIDVALIDITY disagrees", async () => {
-		assert.deepEqual(await guard(200), { ok: false, state: "cursor_invalid" });
-		assert.equal(
-			(await stored()).cursorState,
-			MailboxCursorState.cursor_invalid,
-		);
-	});
-
-	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 guarded = async () =>
-		guardConnectionCursor(
-			imap.connection(),
-			{ mailboxService: store.mailbox },
-			account.accountId,
-			await stored(),
-		);
-
-	it("opens the box and passes other calls through when the cursor holds", async () => {
-		imap.deliver("INBOX", eml({}));
-		const connection = await guarded();
-
-		const box = await connection.openBox("INBOX");
-		const rows = await connection.fetchMessages([1]);
-
-		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(
-			connection.openBox("INBOX"),
-			(err: unknown) =>
-				err instanceof MailboxCursorPausedError &&
-				err.state === "cursor_invalid",
-		);
-	});
-
-	it("trips the mailbox and refuses when the server renumbered it", async () => {
-		const connection = await guarded();
-		imap.renumber("INBOX", 200);
-
-		await assert.rejects(
-			connection.openBox("INBOX"),
-			(err: unknown) =>
-				err instanceof MailboxCursorPausedError &&
-				err.state === "cursor_invalid",
-		);
-		assert.equal(
-			(await stored()).cursorState,
-			MailboxCursorState.cursor_invalid,
-		);
-	});
-});
-
-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,119 +0,0 @@
-import assert from "node:assert/strict";
-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 {
-	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 } : {},
-	});
-
-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 () => {
-		await markAs(MailboxSyncStatus.failed);
-
-		await requestDelete();
-
-		assert.equal((await current()).syncStatus, MailboxSyncStatus.deleting);
-		assert.equal(queue.length, 1);
-	});
-
-	it("answers a second delete with a 409 and enqueues nothing", async () => {
-		await requestDelete();
-
-		await assert.rejects(
-			requestDelete(),
-			(error: unknown) =>
-				(error as { statusCode?: number }).statusCode === 409 &&
-				(error as Error).message ===
-					'A delete is already in progress for "Receipts".',
-		);
-		assert.equal(queue.length, 1);
-	});
-
-	it("answers a delete during a rename with a 409 naming the rename", async () => {
-		await markAs(MailboxSyncStatus.pending, "Bonnen");
-
-		await assert.rejects(
-			requestDelete(),
-			(error: unknown) =>
-				(error as Error).message === 'A rename is in progress for "Receipts".',
-		);
-	});
-});
-
-describe("MailboxManagementService.failDelete", () => {
-	it("marks the row failed and keeps its path, with no rename target", async () => {
-		await requestDelete();
-
-		await management().failDelete(
-			account.accountId,
-			receipts.mailboxId,
-			"Permission denied",
-		);
-
-		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 () => {
-		await assert.rejects(
-			management().failDelete(account.accountId, "mbx-gone", "denied"),
-			(error: unknown) => (error as Error).name === "NotFoundError",
-		);
-	});
-});

package/src/mailbox-management.test.ts

@@ -1,243 +0,0 @@
-import assert from "node:assert";
-import { afterEach, beforeEach, describe, it } from "node:test";
-import type { AccountItem, MailboxItem } from "@remit/data-ports";
-import { MailboxSyncStatus } from "@remit/domain-enums";
-import {
-	MailboxManagementService,
-	parseMailboxPath,
-	validateMailboxOperation,
-	validateMailboxPath,
-} from "./mailbox-management.js";
-import {
-	type FakeImapConnection,
-	FakeImapServer,
-} from "./test-helpers/fake-imap.js";
-import {
-	openStore,
-	type Store,
-	seedAccount,
-	seedMailbox,
-} from "./test-helpers/test-store.js";
-
-describe("parseMailboxPath", () => {
-	it("parses simple path", () => {
-		const result = parseMailboxPath("INBOX");
-		assert.strictEqual(result.name, "INBOX");
-		assert.strictEqual(result.parent, null);
-		assert.strictEqual(result.depth, 1);
-	});
-
-	it("parses nested path with default delimiter", () => {
-		const result = parseMailboxPath("Work/Projects/ClientA");
-		assert.strictEqual(result.name, "ClientA");
-		assert.strictEqual(result.parent, "Work/Projects");
-		assert.strictEqual(result.depth, 3);
-	});
-
-	it("parses nested path with custom delimiter", () => {
-		const result = parseMailboxPath("Work.Projects.ClientA", ".");
-		assert.strictEqual(result.name, "ClientA");
-		assert.strictEqual(result.parent, "Work.Projects");
-		assert.strictEqual(result.depth, 3);
-	});
-
-	it("handles two-level path", () => {
-		const result = parseMailboxPath("Personal/Archive");
-		assert.strictEqual(result.name, "Archive");
-		assert.strictEqual(result.parent, "Personal");
-		assert.strictEqual(result.depth, 2);
-	});
-});
-
-describe("validateMailboxPath", () => {
-	it("throws on empty path", () => {
-		assert.throws(() => validateMailboxPath(""), {
-			message: "Mailbox path cannot be empty",
-		});
-	});
-
-	it("throws on whitespace-only path", () => {
-		assert.throws(() => validateMailboxPath("   "), {
-			message: "Mailbox path cannot be empty",
-		});
-	});
-
-	it("throws on double delimiters", () => {
-		assert.throws(() => validateMailboxPath("Work//Projects"), {
-			message: "Mailbox path cannot contain empty hierarchy levels",
-		});
-	});
-
-	it("throws on leading delimiter", () => {
-		assert.throws(() => validateMailboxPath("/Work/Projects"), {
-			message: "Mailbox path cannot start or end with hierarchy delimiter",
-		});
-	});
-
-	it("throws on trailing delimiter", () => {
-		assert.throws(() => validateMailboxPath("Work/Projects/"), {
-			message: "Mailbox path cannot start or end with hierarchy delimiter",
-		});
-	});
-
-	it("accepts valid simple path", () => {
-		assert.doesNotThrow(() => validateMailboxPath("INBOX"));
-	});
-
-	it("accepts valid nested path", () => {
-		assert.doesNotThrow(() => validateMailboxPath("Work/Projects/ClientA"));
-	});
-});
-
-let store: Store;
-let imap: FakeImapServer;
-let account: AccountItem;
-
-beforeEach(async () => {
-	store = await openStore();
-	imap = new FakeImapServer();
-	account = await seedAccount(store);
-});
-
-afterEach(() => store.close());
-
-const pending = (fullPath: string) =>
-	seedMailbox(store, account, fullPath, {
-		overrides: { syncStatus: MailboxSyncStatus.pending },
-	});
-
-const syncCreate = (
-	mailbox: MailboxItem,
-	connection: FakeImapConnection = imap.connection(),
-	subscribe?: boolean,
-) =>
-	new MailboxManagementService(store.mailbox).syncCreate(
-		account.accountId,
-		mailbox.mailboxId,
-		mailbox.fullPath,
-		async () => connection,
-		subscribe,
-	);
-
-const current = (mailbox: MailboxItem) =>
-	store.mailbox.get(account.accountId, mailbox.mailboxId);
-
-describe("MailboxManagementService.syncCreate", () => {
-	it("adopts the path the server created under its prefix, keeping the row", async () => {
-		imap.namespacePrefix = "INBOX/";
-		const requested = await pending("Notifications");
-
-		const result = await syncCreate(requested);
-
-		assert.strictEqual(result.success, true);
-		assert.ok(imap.hasFolder("INBOX/Notifications"));
-		const row = await current(requested);
-		assert.strictEqual(row.fullPath, "INBOX/Notifications");
-		assert.strictEqual(row.syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("drops the pending row when the server path already has a folder (#318)", async () => {
-		imap.namespacePrefix = "INBOX/";
-		imap.addFolder("INBOX/Notifications");
-		const existing = await seedMailbox(store, account, "INBOX/Notifications");
-		const requested = await pending("Notifications");
-
-		const result = await syncCreate(requested);
-
-		assert.deepStrictEqual(result, {
-			success: true,
-			existing: {
-				mailboxId: existing.mailboxId,
-				fullPath: "INBOX/Notifications",
-			},
-		});
-		await assert.rejects(current(requested));
-	});
-
-	it("keeps the requested path when the server does", async () => {
-		const requested = await pending("Work");
-
-		await syncCreate(requested);
-
-		const row = await current(requested);
-		assert.strictEqual(row.fullPath, "Work");
-		assert.strictEqual(row.syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("still adopts the server path when the fresh list cannot resolve it", async () => {
-		imap.namespacePrefix = "INBOX/";
-		const requested = await pending("Notifications");
-		const connection = imap.connection();
-		connection.listMailboxes = async () => [];
-
-		await syncCreate(requested, connection);
-
-		assert.strictEqual(
-			(await current(requested)).fullPath,
-			"INBOX/Notifications",
-		);
-	});
-
-	it("falls back to the requested path when the create result names none", async () => {
-		const requested = await pending("Archive");
-		const connection = imap.connection();
-		const create = connection.createMailbox;
-		connection.createMailbox = async (path) => {
-			await create(path);
-			return { created: true } as { path: string; created: boolean };
-		};
-
-		await syncCreate(requested, connection, true);
-
-		assert.strictEqual(imap.isSubscribed("Archive"), true);
-		const row = await current(requested);
-		assert.strictEqual(row.fullPath, "Archive");
-		assert.strictEqual(row.syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("does not settle a row a rename has claimed since", async () => {
-		const requested = await pending("Archive");
-		await store.mailbox.transition(account.accountId, requested.mailboxId, {
-			from: [MailboxSyncStatus.pending],
-			to: MailboxSyncStatus.pending,
-			set: { pendingPath: "Archief" },
-		});
-
-		await syncCreate(requested);
-
-		const row = await current(requested);
-		assert.strictEqual(row.syncStatus, MailboxSyncStatus.pending);
-		assert.strictEqual(row.pendingPath, "Archief");
-	});
-});
-
-describe("validateMailboxOperation", () => {
-	it("throws when deleting INBOX", () => {
-		assert.throws(() => validateMailboxOperation("delete", "INBOX"), {
-			message: "Cannot delete INBOX",
-		});
-	});
-
-	it("throws when deleting INBOX (case insensitive)", () => {
-		assert.throws(() => validateMailboxOperation("delete", "inbox"), {
-			message: "Cannot delete INBOX",
-		});
-	});
-
-	it("allows deleting other mailboxes", () => {
-		assert.doesNotThrow(() => validateMailboxOperation("delete", "Archive"));
-	});
-
-	it("throws when renaming INBOX", () => {
-		// The server would move INBOX's mail to the new name and leave an empty
-		// INBOX behind — a bulk move, not a path update (D5). The API refuses it;
-		// this is the worker's backstop.
-		assert.throws(() => validateMailboxOperation("rename", "INBOX"), {
-			message: "Cannot rename INBOX",
-		});
-	});
-
-	it("allows renaming other mailboxes", () => {
-		assert.doesNotThrow(() => validateMailboxOperation("rename", "Archive"));
-	});
-});