@remit/mailbox-service 0.0.26 → 0.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.26",
+  "version": "0.0.28",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/mailbox-management.test.ts

@@ -1,10 +1,18 @@
 import assert from "node:assert";
 import { describe, it } from "node:test";
+import type { IMailboxRepository } from "@remit/data-ports";
+import { MailboxSyncStatus } from "@remit/domain-enums";
 import {
+	MailboxManagementService,
 	parseMailboxPath,
 	validateMailboxOperation,
 	validateMailboxPath,
 } from "./mailbox-management.js";
+import type {
+	FlatMailboxInfo,
+	IImapConnection,
+	ImapBoxStatus,
+} from "./types.js";
 
 describe("parseMailboxPath", () => {
 	it("parses simple path", () => {
@@ -76,6 +84,161 @@ describe("validateMailboxPath", () => {
 	});
 });
 
+const boxStatus = (path: string): ImapBoxStatus => ({
+	name: path,
+	readOnly: true,
+	uidvalidity: 42,
+	uidnext: 7,
+	flags: [],
+	permFlags: [],
+	persistentUIDs: true,
+	messages: { total: 0, new: 0 },
+	newKeywords: false,
+});
+
+const recordingRepo = () => {
+	const updates: Array<{ mailboxId: string; patch: Record<string, unknown> }> =
+		[];
+	const repo = {
+		update: async (
+			_accountId: string,
+			mailboxId: string,
+			patch: Record<string, unknown>,
+		) => {
+			updates.push({ mailboxId, patch });
+			return {} as never;
+		},
+	} as unknown as IMailboxRepository;
+	return { repo, updates };
+};
+
+const stubConnection = (
+	createdPath: string,
+	listed: string[],
+): { connection: IImapConnection; opened: string[] } => {
+	const opened: string[] = [];
+	const connection = {
+		createMailbox: async (_path: string) => ({
+			path: createdPath,
+			created: true,
+		}),
+		subscribeMailbox: async () => undefined,
+		listMailboxes: async (): Promise<FlatMailboxInfo[]> =>
+			listed.map((fullPath) => ({
+				fullPath,
+				name: fullPath.split("/").pop() ?? fullPath,
+				delimiter: "/",
+				attributes: [],
+				parentPath: null,
+			})),
+		openBox: async (path: string) => {
+			opened.push(path);
+			return boxStatus(path);
+		},
+		closeBox: async () => undefined,
+	} as unknown as IImapConnection;
+	return { connection, opened };
+};
+
+describe("MailboxManagementService.syncCreate — server path normalization", () => {
+	it("adopts the server-materialized path as the row's identity when it is prefixed", async () => {
+		const { repo, updates } = recordingRepo();
+		const { connection, opened } = stubConnection("INBOX/Notifications", [
+			"INBOX/Notifications",
+		]);
+		const service = new MailboxManagementService(repo);
+
+		const result = await service.syncCreate(
+			"acc-1",
+			"mbx-1",
+			"Notifications",
+			async () => connection,
+		);
+
+		assert.strictEqual(result.success, true);
+		// The mailbox is opened at the server's path, not the requested leaf.
+		assert.deepStrictEqual(opened, ["INBOX/Notifications"]);
+		assert.strictEqual(updates.length, 1);
+		// The row keeps its id and takes on the prefixed path, so the next reconcile
+		// updates it in place instead of insert+delete — every reference survives.
+		assert.strictEqual(updates[0].mailboxId, "mbx-1");
+		assert.strictEqual(updates[0].patch.fullPath, "INBOX/Notifications");
+		assert.strictEqual(updates[0].patch.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	it("leaves the path untouched when the server keeps it as requested", async () => {
+		const { repo, updates } = recordingRepo();
+		const { connection } = stubConnection("Work", ["Work"]);
+		const service = new MailboxManagementService(repo);
+
+		await service.syncCreate("acc-1", "mbx-2", "Work", async () => connection);
+
+		assert.strictEqual(updates.length, 1);
+		assert.ok(!("fullPath" in updates[0].patch));
+		assert.strictEqual(updates[0].patch.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	it("still adopts the server path when the fresh list cannot resolve it", async () => {
+		const { repo, updates } = recordingRepo();
+		const { connection, opened } = stubConnection("INBOX/Notifications", []);
+		const service = new MailboxManagementService(repo);
+
+		await service.syncCreate(
+			"acc-1",
+			"mbx-3",
+			"Notifications",
+			async () => connection,
+		);
+
+		assert.deepStrictEqual(opened, []);
+		assert.strictEqual(updates.length, 1);
+		assert.strictEqual(updates[0].patch.fullPath, "INBOX/Notifications");
+		assert.strictEqual(updates[0].patch.syncStatus, MailboxSyncStatus.synced);
+	});
+
+	it("falls back to the requested path when the create result carries none", async () => {
+		const { repo, updates } = recordingRepo();
+		const opened: string[] = [];
+		const subscribed: string[] = [];
+		const connection = {
+			createMailbox: async (_path: string) => ({ created: true }),
+			subscribeMailbox: async (p: string) => {
+				subscribed.push(p);
+			},
+			listMailboxes: async (): Promise<FlatMailboxInfo[]> => [
+				{
+					fullPath: "Archive",
+					name: "Archive",
+					delimiter: "/",
+					attributes: [],
+					parentPath: null,
+				},
+			],
+			openBox: async (p: string) => {
+				opened.push(p);
+				return boxStatus(p);
+			},
+			closeBox: async () => undefined,
+		} as unknown as IImapConnection;
+		const service = new MailboxManagementService(repo);
+
+		await service.syncCreate(
+			"acc-1",
+			"mbx-4",
+			"Archive",
+			async () => connection,
+			true,
+		);
+
+		// A thin result never blanks fullPath — the requested path is used throughout.
+		assert.deepStrictEqual(subscribed, ["Archive"]);
+		assert.deepStrictEqual(opened, ["Archive"]);
+		assert.strictEqual(updates.length, 1);
+		assert.ok(!("fullPath" in updates[0].patch));
+		assert.strictEqual(updates[0].patch.syncStatus, MailboxSyncStatus.synced);
+	});
+});
+
 describe("validateMailboxOperation", () => {
 	it("throws when deleting INBOX", () => {
 		assert.throws(() => validateMailboxOperation("delete", "INBOX"), {

package/src/mailbox-management.ts

@@ -135,25 +135,41 @@ export class MailboxManagementService {
 
 		const result = await connection.createMailbox(path);
 
+		// The server is free to materialize the requested path under a namespace
+		// prefix — a Dovecot INBOX namespace turns "Notifications" into
+		// "INBOX/Notifications". `mailboxCreate` reports the canonical path the
+		// server assigned; adopt it as this row's identity so the next mailbox
+		// reconcile matches it by fullPath and updates it in place, rather than
+		// inserting a fresh row for the prefixed path and deleting this one — which
+		// would strand every filter and placement that references this mailboxId.
+		// Fall back to the requested path when the result carries no usable path,
+		// so a thin result never blanks the row's fullPath to undefined.
+		const serverPath =
+			typeof result.path === "string" && result.path.length > 0
+				? result.path
+				: path;
+		const pathUpdate = serverPath !== path ? { fullPath: serverPath } : {};
+
 		this.log.info(
-			{ mailboxId, path, created: result.created },
+			{ mailboxId, path, serverPath, created: result.created },
 			"Created mailbox on IMAP server",
 		);
 
 		if (subscribe) {
-			await connection.subscribeMailbox(path);
-			this.log.info({ mailboxId, path }, "Subscribed to mailbox");
+			await connection.subscribeMailbox(serverPath);
+			this.log.info({ mailboxId, path: serverPath }, "Subscribed to mailbox");
 		}
 
 		// Refresh mailbox list to get UIDVALIDITY and other attributes
 		const mailboxes = await connection.listMailboxes();
-		const mailboxInfo = mailboxes.find((m) => m.fullPath === path);
+		const mailboxInfo = mailboxes.find((m) => m.fullPath === serverPath);
 
 		if (mailboxInfo) {
 			// Open the mailbox to get UIDVALIDITY and other status info
-			const status = await connection.openBox(path, true);
+			const status = await connection.openBox(serverPath, true);
 
 			await this.mailboxService.update(accountId, mailboxId, {
+				...pathUpdate,
 				uidValidity: status.uidvalidity,
 				uidNext: status.uidnext,
 				messageCount: status.messages.total,
@@ -164,6 +180,7 @@ export class MailboxManagementService {
 		} else {
 			// Mark as synced even if we couldn't get full info
 			await this.mailboxService.update(accountId, mailboxId, {
+				...pathUpdate,
 				syncStatus: MailboxSyncStatus.synced,
 			});
 		}

package/src/mailbox-sync.test.ts

@@ -4,7 +4,11 @@ import type {
 	IMailboxRepository,
 	IMailboxSpecialUseRepository,
 } from "@remit/data-ports";
-import { MailboxCursorState, MailboxSpecialUse } from "@remit/domain-enums";
+import {
+	MailboxCursorState,
+	MailboxSpecialUse,
+	MailboxSyncStatus,
+} from "@remit/domain-enums";
 import { parseImapAttributes } from "./attribute-mapper.js";
 import { MailboxSyncService } from "./mailbox-sync.js";
 import type { IImapConnection, ImapNamespaces } from "./types.js";
@@ -180,3 +184,128 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 		assert.equal("cursorState" in (uidValidityUpdate ?? {}), false);
 	});
 });
+
+describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending folders (#290)", () => {
+	const namespaces: ImapNamespaces = {
+		personal: [{ prefix: "", delimiter: "/" }],
+		other: [],
+		shared: [],
+	};
+
+	// The server lists only INBOX: neither user folder is on it yet.
+	const serverConnection = (): IImapConnection =>
+		({
+			getNamespaces: async () => namespaces,
+			listMailboxes: async () => [
+				{
+					fullPath: "INBOX",
+					name: "INBOX",
+					delimiter: "/",
+					attributes: [],
+					parentPath: null,
+				},
+			],
+			getMailboxStatus: async () => ({
+				messages: 0,
+				recent: 0,
+				unseen: 0,
+				uidNext: 1,
+				uidValidity: 1,
+				highestModseq: "0",
+				deletedCount: 0,
+			}),
+		}) as unknown as IImapConnection;
+
+	const buildServices = (
+		existing: Array<{
+			mailboxId: string;
+			fullPath: string;
+			syncStatus?: string;
+		}>,
+	) => {
+		const deleted: string[] = [];
+		const mailboxService = {
+			listByAccount: async () => ({
+				items: existing.map((m) => ({
+					mailboxId: m.mailboxId,
+					fullPath: m.fullPath,
+					uidNext: 1,
+					uidValidity: 1,
+					messageCount: 0,
+					unseenCount: 0,
+					deletedCount: 0,
+					highestModseq: "0",
+					specialUse: undefined,
+					syncStatus: m.syncStatus,
+				})),
+				continuationToken: undefined,
+			}),
+			update: async () => ({}),
+			delete: async (_accountId: string, mailboxId: string) => {
+				deleted.push(mailboxId);
+			},
+			create: async () => ({}),
+		} as unknown as IMailboxRepository;
+
+		const specialUseService = {
+			listByMailboxId: async () => [],
+			deleteByMailboxId: async () => undefined,
+			createMany: async () => undefined,
+		} as unknown as IMailboxSpecialUseRepository;
+
+		return { mailboxService, specialUseService, deleted };
+	};
+
+	it("keeps a pending folder the server has not listed yet", async () => {
+		// The folder was just created locally; MAILBOX_CREATE has not reached the
+		// server, so the LIST omits it. Deleting the row here races the create and
+		// wedges the account's mailbox-sync FIFO group for a full visibility window.
+		const { mailboxService, specialUseService, deleted } = buildServices([
+			{
+				mailboxId: "inbox",
+				fullPath: "INBOX",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+			{
+				mailboxId: "pending-folder",
+				fullPath: "New Folder",
+				syncStatus: MailboxSyncStatus.pending,
+			},
+		]);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection(),
+		);
+
+		assert.deepEqual(deleted, []);
+		assert.equal(result.deleted, 0);
+	});
+
+	it("still deletes a synced folder that has left the server", async () => {
+		// A folder that was confirmed on the server and is now gone is a genuine
+		// server-side deletion; the reconcile must still reap it.
+		const { mailboxService, specialUseService, deleted } = buildServices([
+			{
+				mailboxId: "inbox",
+				fullPath: "INBOX",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+			{
+				mailboxId: "synced-gone",
+				fullPath: "Old Folder",
+				syncStatus: MailboxSyncStatus.synced,
+			},
+		]);
+		const service = new MailboxSyncService(mailboxService, specialUseService);
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection(),
+		);
+
+		assert.deepEqual(deleted, ["synced-gone"]);
+		assert.equal(result.deleted, 1);
+	});
+});

package/src/mailbox-sync.ts

@@ -13,6 +13,7 @@ import type {
 import {
 	MailboxCursorState,
 	MailboxSpecialUse,
+	MailboxSyncStatus,
 	NamespaceType,
 } from "@remit/domain-enums";
 import pMap from "p-map";
@@ -198,13 +199,21 @@ export class MailboxSyncService {
 
 		// Handle deleted mailboxes (exist in DB but not on server)
 		for (const existing of existingMailboxes) {
-			if (!seenPaths.has(existing.fullPath)) {
-				await this.mailboxService.delete(account.accountId, existing.mailboxId);
-				console.info(
-					`Deleted mailbox: ${existing.mailboxId} (${existing.fullPath})`,
-				);
-				result.deleted++;
-			}
+			if (seenPaths.has(existing.fullPath)) continue;
+			// A `pending` row is a folder the user just created (or renamed) whose
+			// MAILBOX_CREATE/RENAME has not yet reached the server, so its absence
+			// from the LIST is expected, not a server-side deletion. Deleting it
+			// races the create: the row vanishes, then MAILBOX_CREATE fails with
+			// NotFoundError trying to mark it synced, and — sharing this account's
+			// mailboxes FIFO group — that un-acked failure stalls every later
+			// mailbox sync for the queue's whole visibility window (#290). Leave
+			// pending rows to the create/rename flow that owns them.
+			if (existing.syncStatus === MailboxSyncStatus.pending) continue;
+			await this.mailboxService.delete(account.accountId, existing.mailboxId);
+			console.info(
+				`Deleted mailbox: ${existing.mailboxId} (${existing.fullPath})`,
+			);
+			result.deleted++;
 		}
 
 		return result;