@remit/mailbox-service 0.0.112 → 0.0.114

package/src/mailbox-rename-subtree.test.ts

@@ -1,287 +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 { FolderGoneUpstreamError } from "./mailbox-upstream.js";
-import {
-	type FakeImapConnection,
-	FakeImapServer,
-} from "./test-helpers/fake-imap.js";
-import {
-	beforeNext,
-	openStore,
-	type Store,
-	seedAccount,
-	seedMailbox,
-} from "./test-helpers/test-store.js";
-
-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 folder = async (
-	fullPath: string,
-	pendingPath?: string,
-	overrides: Partial<MailboxItem> = {},
-): Promise<MailboxItem> => {
-	imap.addFolder(fullPath);
-	const mailbox = await seedMailbox(store, account, fullPath, { overrides });
-	if (!pendingPath) return mailbox;
-	const recorded = await store.mailbox.transition(
-		account.accountId,
-		mailbox.mailboxId,
-		{
-			from: [MailboxSyncStatus.synced],
-			to: MailboxSyncStatus.pending,
-			set: { pendingPath },
-		},
-	);
-	if (!recorded) throw new Error(`could not record a rename on ${fullPath}`);
-	return recorded;
-};
-
-const current = (mailbox: MailboxItem) =>
-	store.mailbox.get(account.accountId, mailbox.mailboxId);
-
-const management = () => new MailboxManagementService(store.mailbox);
-
-const renameWork = (connection: FakeImapConnection = imap.connection()) =>
-	management().syncRename(
-		account.accountId,
-		workId as string,
-		"Work",
-		"Projects",
-		async () => connection,
-	);
-
-let workId: string | undefined;
-
-const work = async (
-	pendingPath: string | null = "Projects",
-	overrides: Partial<MailboxItem> = {},
-) => {
-	const mailbox = await folder("Work", pendingPath ?? undefined, overrides);
-	workId = mailbox.mailboxId;
-	return mailbox;
-};
-
-const assertAt = async (
-	mailbox: MailboxItem,
-	fullPath: string,
-	syncStatus: MailboxItem["syncStatus"],
-	pendingPath?: string,
-) => {
-	const row = await current(mailbox);
-	assert.equal(row.fullPath, fullPath);
-	assert.equal(row.syncStatus, syncStatus);
-	assert.equal(row.pendingPath, pendingPath);
-};
-
-describe("MailboxManagementService.syncRename settles one intent", () => {
-	it("adopts the path the server resolved over the one requested", async () => {
-		const parent = await work();
-		const child = await folder("Work/2026", "Projects/2026");
-		imap.namespacePrefix = "INBOX/";
-
-		await renameWork();
-
-		await assertAt(parent, "INBOX/Projects", MailboxSyncStatus.synced);
-		await assertAt(child, "INBOX/Projects/2026", MailboxSyncStatus.synced);
-	});
-
-	it("leaves rows it must not claim alone", async () => {
-		const parent = await work();
-		const interloper = await folder("Projects/Fresh");
-		const elsewhere = await folder("Admin", "Beheer");
-		const sameBranch = await folder("Other", "Projects/Old");
-		const offRebase = await folder("Work/2026", "Projects/Archief");
-
-		await renameWork();
-
-		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
-		await assertAt(interloper, "Projects/Fresh", MailboxSyncStatus.synced);
-		await assertAt(elsewhere, "Admin", MailboxSyncStatus.pending, "Beheer");
-		await assertAt(
-			sameBranch,
-			"Other",
-			MailboxSyncStatus.pending,
-			"Projects/Old",
-		);
-		await assertAt(
-			offRebase,
-			"Work/2026",
-			MailboxSyncStatus.pending,
-			"Projects/Archief",
-		);
-	});
-
-	it("settles the rest when a descendant is deleted mid-settle", async () => {
-		const parent = await work();
-		const gone = await folder("Work/Gone", "Projects/Gone");
-		const child = await folder("Work/2026", "Projects/2026");
-		beforeNext(store.mailbox, "transition", () =>
-			store.mailbox.delete(account.accountId, gone.mailboxId),
-		);
-
-		const result = await renameWork();
-
-		assert.equal(result.success, true);
-		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
-		await assertAt(child, "Projects/2026", MailboxSyncStatus.synced);
-	});
-
-	for (const [label, pendingPath] of [
-		["already settled", null],
-		["pending for another target", "Beheer"],
-	] as const) {
-		it(`issues no RENAME when the row is ${label}`, async () => {
-			await work(pendingPath);
-
-			const result = await renameWork();
-
-			assert.equal(result.success, true);
-			assert.ok(imap.hasFolder("Work"));
-			assert.equal(imap.hasFolder("Projects"), false);
-		});
-	}
-});
-
-describe("MailboxManagementService.syncRename reads a NONEXISTENT answer", () => {
-	it("settles when the source has moved because the rename already landed", async () => {
-		const parent = await work();
-		await imap.connection().renameMailbox("Work", "Projects");
-
-		const result = await renameWork();
-
-		assert.equal(result.success, true);
-		await assertAt(parent, "Projects", MailboxSyncStatus.synced);
-	});
-
-	it("reads the target through the account's namespace prefix", async () => {
-		const parent = await work("Projects", {
-			hierarchyDelimiter: ".",
-			namespacePrefix: "INBOX.",
-		});
-		imap.removeFolder("Work");
-		imap.addFolder("INBOX.Projects");
-
-		const result = await renameWork();
-
-		assert.equal(result.success, true);
-		assert.equal((await current(parent)).syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("reports the folder gone, carrying the server's answer, when neither path is listed", async () => {
-		await work();
-		imap.removeFolder("Work");
-
-		await assert.rejects(
-			renameWork(),
-			(error: unknown) =>
-				error instanceof FolderGoneUpstreamError &&
-				(error.cause as { serverResponseCode?: string })?.serverResponseCode ===
-					"NONEXISTENT",
-		);
-	});
-
-	it("refuses rather than confirming a delete when the source is still listed", async () => {
-		await work();
-		const connection = imap.connection();
-		connection.renameMailbox = async () => {
-			throw Object.assign(new Error("Command failed"), {
-				serverResponseCode: "NONEXISTENT",
-			});
-		};
-
-		await assert.rejects(
-			renameWork(connection),
-			(error: unknown) =>
-				!(error instanceof FolderGoneUpstreamError) &&
-				(error as { serverResponseCode?: string }).serverResponseCode ===
-					"NONEXISTENT",
-		);
-	});
-
-	it("refuses rather than confirming a delete when the listing cannot be read", async () => {
-		await work();
-		imap.removeFolder("Work");
-		const connection = imap.connection();
-		connection.listMailboxes = async () => {
-			throw new Error("IMAP connection lost");
-		};
-
-		await assert.rejects(
-			renameWork(connection),
-			(error: unknown) => !(error instanceof FolderGoneUpstreamError),
-		);
-	});
-});
-
-describe("MailboxManagementService.failRename", () => {
-	const fail = () =>
-		management().failRename(
-			account.accountId,
-			workId as string,
-			"Work",
-			"Projects",
-			"Permission denied",
-		);
-
-	it("marks every row this rename recorded failed, keeping path and target", async () => {
-		const parent = await work();
-		const child = await folder("Work/2026", "Projects/2026");
-		const other = await folder("Other", "Projects/Old");
-
-		await fail();
-
-		await assertAt(parent, "Work", MailboxSyncStatus.failed, "Projects");
-		await assertAt(
-			child,
-			"Work/2026",
-			MailboxSyncStatus.failed,
-			"Projects/2026",
-		);
-		await assertAt(other, "Other", MailboxSyncStatus.pending, "Projects/Old");
-	});
-
-	it("raises a NotFoundError when the folder row is gone", async () => {
-		workId = "mbx-gone";
-
-		await assert.rejects(
-			fail(),
-			(error: unknown) => (error as Error).name === "NotFoundError",
-		);
-	});
-
-	it("records nothing, quietly, for a row that carries no intent", async () => {
-		const parent = await work(null);
-
-		await fail();
-
-		await assertAt(parent, "Work", MailboxSyncStatus.synced);
-	});
-
-	it("fails a rename the connection never issued as a refusal", async () => {
-		const parent = await work();
-		const connection = imap.connection();
-		connection.renameMailbox = async () => {
-			throw new Error(
-				'Rename of "Work" was not issued: the IMAP connection is not ready',
-			);
-		};
-
-		await assert.rejects(renameWork(connection), /not ready/);
-		await fail();
-
-		await assertAt(parent, "Work", MailboxSyncStatus.failed, "Projects");
-	});
-});

package/src/mailbox-sync.test.ts

@@ -1,286 +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,
-	MailboxSpecialUse,
-	MailboxSyncStatus,
-} from "@remit/domain-enums";
-import { parseImapAttributes } from "./attribute-mapper.js";
-import { MailboxSyncService } from "./mailbox-sync.js";
-import {
-	eml,
-	type FakeImapConnection,
-	FakeImapServer,
-} from "./test-helpers/fake-imap.js";
-import {
-	openStore,
-	type Store,
-	seedAccount,
-	seedMailbox,
-	silentLog,
-} from "./test-helpers/test-store.js";
-
-describe("parseImapAttributes – locale invariance (#194)", () => {
-	it("recognizes \\Sent regardless of folder name", () => {
-		const dutch = parseImapAttributes(["\\HasNoChildren", "\\Sent"]);
-		assert.deepEqual(dutch.specialUse, [MailboxSpecialUse.Sent]);
-
-		const english = parseImapAttributes(["\\Sent"]);
-		assert.deepEqual(english.specialUse, [MailboxSpecialUse.Sent]);
-	});
-
-	it("recognizes \\Drafts on a localized 'Concepten' folder", () => {
-		const parsed = parseImapAttributes(["\\Drafts"]);
-		assert.deepEqual(parsed.specialUse, [MailboxSpecialUse.Drafts]);
-	});
-
-	it("returns an empty list when no flag is present", () => {
-		const parsed = parseImapAttributes(["\\HasNoChildren"]);
-		assert.deepEqual(parsed.specialUse, []);
-	});
-
-	it("normalizes case: \\sent is treated the same as \\Sent", () => {
-		const parsed = parseImapAttributes(["\\sent"]);
-		assert.deepEqual(parsed.specialUse, [MailboxSpecialUse.Sent]);
-	});
-});
-
-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 sweep = (connection: FakeImapConnection = imap.connection()) =>
-	new MailboxSyncService(
-		store.mailbox,
-		store.mailboxSpecialUse,
-		silentLog,
-	).syncMailboxes({ accountId: account.accountId }, connection);
-
-const rows = async () =>
-	(await store.mailbox.listAllByAccount(account.accountId)).sort((a, b) =>
-		a.fullPath.localeCompare(b.fullPath),
-	);
-
-const paths = async () => (await rows()).map((mailbox) => mailbox.fullPath);
-
-const row = (mailbox: MailboxItem) =>
-	store.mailbox.get(account.accountId, mailbox.mailboxId);
-
-const byPath = async (fullPath: string) => {
-	const found = await store.mailbox.findByPath(account.accountId, fullPath);
-	if (!found) throw new Error(`no row at ${fullPath}`);
-	return found;
-};
-
-const inState = async (
-	fullPath: string,
-	syncStatus: MailboxItem["syncStatus"],
-	pendingPath?: string,
-) => {
-	const mailbox = await seedMailbox(store, account, fullPath, {
-		overrides: { syncStatus },
-	});
-	if (!pendingPath) return mailbox;
-	const recorded = await store.mailbox.transition(
-		account.accountId,
-		mailbox.mailboxId,
-		{ from: [syncStatus], to: syncStatus, set: { pendingPath } },
-	);
-	if (!recorded) throw new Error(`could not record ${pendingPath}`);
-	return recorded;
-};
-
-describe("the STATUS sweep and the mailbox cursor", () => {
-	const swept = async () => {
-		imap.addFolder("INBOX", { uidValidity: 1 });
-		imap.deliver("INBOX", eml({}));
-		await sweep();
-		return byPath("INBOX");
-	};
-
-	it("trips cursor_invalid without touching the message-sync cursor", async () => {
-		const inbox = await swept();
-		imap.renumber("INBOX", 2);
-
-		await sweep();
-
-		const after = await row(inbox);
-		assert.equal(after.cursorState, MailboxCursorState.cursor_invalid);
-		assert.equal(after.highestModseq, inbox.highestModseq);
-	});
-
-	it("writes nothing when only the server mod-sequence moved", async () => {
-		const inbox = await swept();
-		imap.store("INBOX", [1], ["\\Flagged"]);
-
-		await sweep();
-
-		assert.deepEqual(await row(inbox), inbox);
-	});
-});
-
-describe("reconciling the folder list", () => {
-	for (const syncStatus of [
-		MailboxSyncStatus.pending,
-		MailboxSyncStatus.deleting,
-	]) {
-		it(`keeps a ${syncStatus} folder the server omits or lists as \\Noselect`, async () => {
-			imap.addFolder("INBOX");
-			imap.addFolder("Half", { attributes: ["\\Noselect"] });
-			await inState("New Folder", syncStatus);
-			await inState("Half", syncStatus);
-
-			const result = await sweep();
-
-			assert.equal(result.deleted, 0);
-			assert.deepEqual(await paths(), ["Half", "INBOX", "New Folder"]);
-		});
-	}
-
-	it("deletes a synced folder that has left the server", async () => {
-		imap.addFolder("INBOX");
-		await seedMailbox(store, account, "Old Folder");
-
-		const result = await sweep();
-
-		assert.equal(result.deleted, 1);
-		assert.deepEqual(await paths(), ["INBOX"]);
-	});
-
-	it("discovers a new folder as synced", async () => {
-		imap.addFolder("INBOX");
-
-		await sweep();
-
-		assert.equal((await byPath("INBOX")).syncStatus, MailboxSyncStatus.synced);
-	});
-
-	it("inserts no second row for the path a pending rename is on its way to", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Records/2025");
-		await inState("Archive/2025", MailboxSyncStatus.pending, "Records/2025");
-
-		const result = await sweep();
-
-		assert.equal(result.created, 1);
-		assert.deepEqual(await paths(), ["Archive/2025", "INBOX"]);
-	});
-
-	it("discovers a failed rename's target as a folder of its own", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Archive/2025");
-		imap.addFolder("Records/2025");
-		await inState("Archive/2025", MailboxSyncStatus.failed, "Records/2025");
-
-		await sweep();
-
-		assert.deepEqual(await paths(), ["Archive/2025", "INBOX", "Records/2025"]);
-	});
-});
-
-describe("a lookalike of a flagged folder", () => {
-	it("keeps folders called Deleted and Bin beside the flagged Trash", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Trash", { attributes: ["\\Trash"] });
-		imap.addFolder("Deleted");
-		imap.addFolder("Bin");
-
-		await sweep();
-
-		assert.deepEqual(await paths(), ["Bin", "Deleted", "INBOX", "Trash"]);
-	});
-
-	it("hides the unflagged twin of a folder the server flagged", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("[Gmail]/Trash", { attributes: ["\\Trash"] });
-		imap.addFolder("Trash");
-
-		await sweep();
-
-		assert.deepEqual(await paths(), ["[Gmail]/Trash", "INBOX"]);
-	});
-
-	it("keeps a folder that holds a role of its own", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Archive", { attributes: ["\\Archive"] });
-		imap.addFolder("INBOX/All Mail");
-
-		await sweep();
-
-		assert.deepEqual(await paths(), ["Archive", "INBOX", "INBOX/All Mail"]);
-	});
-});
-
-describe("a folder leaving mid-sweep", () => {
-	const statusFailingFor = (
-		path: string,
-		before: () => Promise<unknown>,
-		message: string,
-	) => {
-		const connection = imap.connection();
-		const status = connection.getMailboxStatus;
-		connection.getMailboxStatus = async (asked) => {
-			if (asked !== path) return status(asked);
-			await before();
-			throw new Error(message);
-		};
-		return connection;
-	};
-
-	it("asks no STATUS of a folder mid-mutation and leaves its row alone", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Doomed");
-		const doomed = await inState("Doomed", MailboxSyncStatus.deleting);
-		const connection = imap.connection();
-		const asked: string[] = [];
-		const status = connection.getMailboxStatus;
-		connection.getMailboxStatus = (path) => {
-			asked.push(path);
-			return status(path);
-		};
-
-		await sweep(connection);
-
-		assert.deepEqual(asked, ["INBOX"]);
-		assert.deepEqual(await row(doomed), doomed);
-	});
-
-	it("finishes the sweep when the folder whose STATUS failed has been deleted", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Doomed");
-		await sweep();
-		const doomed = await byPath("Doomed");
-
-		await assert.doesNotReject(
-			sweep(
-				statusFailingFor(
-					"Doomed",
-					() => store.mailbox.delete(account.accountId, doomed.mailboxId),
-					"Mailbox doesn't exist: Doomed",
-				),
-			),
-		);
-	});
-
-	it("fails the sweep when the folder whose STATUS failed is still live", async () => {
-		imap.addFolder("INBOX");
-		imap.addFolder("Doomed");
-		await sweep();
-
-		await assert.rejects(
-			sweep(
-				statusFailingFor("Doomed", async () => {}, "connection reset by peer"),
-			),
-			/connection reset by peer/,
-		);
-	});
-});