@remit/mailbox-service 0.0.26 → 0.0.27

package/package.json

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

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;