@remit/mailbox-service 0.0.101 → 0.0.102

package/package.json

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

package/src/mailbox-management.test.ts

@@ -2,6 +2,7 @@ import assert from "node:assert";
 import { describe, it } from "node:test";
 import type {
 	IMailboxRepository,
+	MailboxItem,
 	MailboxTransitionIntent,
 } from "@remit/data-ports";
 import { MailboxSyncStatus } from "@remit/domain-enums";
@@ -99,7 +100,10 @@ const boxStatus = (path: string): ImapBoxStatus => ({
 	newKeywords: false,
 });
 
-const recordingRepo = () => {
+const recordingRepo = (
+	held: Pick<MailboxItem, "mailboxId" | "fullPath">[] = [],
+) => {
+	const removed: string[] = [];
 	const updates: Array<{ mailboxId: string; patch: Record<string, unknown> }> =
 		[];
 	const settles: Array<{
@@ -108,7 +112,11 @@ const recordingRepo = () => {
 	}> = [];
 	const repo: Pick<
 		IMailboxRepository,
-		"update" | "transition" | "findByPathPrefix"
+		| "update"
+		| "transition"
+		| "findByPathPrefix"
+		| "findByPath"
+		| "deleteMailboxWithMail"
 	> = {
 		update: async (
 			_accountId: string,
@@ -127,8 +135,13 @@ const recordingRepo = () => {
 			return {} as never;
 		},
 		findByPathPrefix: async () => [],
+		findByPath: async (_accountId: string, fullPath: string) =>
+			(held.find((row) => row.fullPath === fullPath) as MailboxItem) ?? null,
+		deleteMailboxWithMail: async (_accountId: string, mailboxId: string) => {
+			removed.push(mailboxId);
+		},
 	};
-	return { repo: repo as IMailboxRepository, updates, settles };
+	return { repo: repo as IMailboxRepository, updates, settles, removed };
 };
 
 const stubConnection = (
@@ -185,6 +198,38 @@ describe("MailboxManagementService.syncCreate — server path normalization", ()
 		assert.strictEqual(settles[0].intent.to, MailboxSyncStatus.synced);
 	});
 
+	it("drops the pending row when the prefixed path already has a folder (#318)", async () => {
+		const { repo, settles, updates, removed } = recordingRepo([
+			{ mailboxId: "mbx-existing", fullPath: "INBOX/Notifications" },
+		]);
+		const connection = {
+			createMailbox: async (_path: string) => ({
+				path: "INBOX/Notifications",
+				created: false,
+			}),
+			subscribeMailbox: async () => undefined,
+			listMailboxes: async (): Promise<FlatMailboxInfo[]> => [],
+			openBox: async (path: string) => boxStatus(path),
+			closeBox: async () => undefined,
+		} as unknown as IImapConnection;
+		const service = new MailboxManagementService(repo);
+
+		const result = await service.syncCreate(
+			"acc-1",
+			"mbx-recreated",
+			"Notifications",
+			async () => connection,
+		);
+
+		assert.deepStrictEqual(result, {
+			success: true,
+			existing: { mailboxId: "mbx-existing", fullPath: "INBOX/Notifications" },
+		});
+		assert.deepStrictEqual(removed, ["mbx-recreated"]);
+		assert.deepStrictEqual(settles, []);
+		assert.deepStrictEqual(updates, []);
+	});
+
 	it("leaves the path untouched when the server keeps it as requested", async () => {
 		const { repo, settles } = recordingRepo();
 		const { connection } = stubConnection("Work", ["Work"]);

package/src/mailbox-management.ts

@@ -48,6 +48,7 @@ export interface MailboxManagementSyncResult {
 	 * which is how a caller tells the two apart without a second read.
 	 */
 	renamed?: { oldPath: string; newPath: string; delimiter: string };
+	existing?: { mailboxId: string; fullPath: string };
 }
 
 /**
@@ -304,6 +305,30 @@ export class MailboxManagementService {
 			this.log.info({ mailboxId, path: serverPath }, "Subscribed to mailbox");
 		}
 
+		const holder =
+			confirmedPath === undefined
+				? null
+				: await this.mailboxService.findByPath(accountId, confirmedPath);
+		if (holder && holder.mailboxId !== mailboxId) {
+			await this.mailboxService.deleteMailboxWithMail(accountId, mailboxId);
+			this.log.info(
+				{
+					accountId,
+					mailboxId,
+					intent: "create",
+					path,
+					serverPath,
+					existingMailboxId: holder.mailboxId,
+					outcome: "already-exists",
+				},
+				"Folder already exists at the path the server resolved",
+			);
+			return {
+				success: true,
+				existing: { mailboxId: holder.mailboxId, fullPath: holder.fullPath },
+			};
+		}
+
 		// Refresh mailbox list to get UIDVALIDITY and other attributes
 		const mailboxes = await connection.listMailboxes();
 		const mailboxInfo = mailboxes.find((m) => m.fullPath === serverPath);

package/src/mailbox-queue.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { SendMessageCommand, type SQSClient } from "@aws-sdk/client-sqs";
 import type {
 	CreateMailboxInput,
+	CreateMailboxResult,
 	IMailboxRepository,
 	MailboxItem,
 } from "@remit/data-ports";
@@ -120,18 +121,19 @@ export class MailboxQueueService {
 	 * @param input - The mailbox creation input (without syncStatus)
 	 * @param accountId - The account ID for the IMAP sync event
 	 * @param subscribe - Whether to subscribe to the mailbox after creation
-	 * @returns The created mailbox
+	 * @returns The created mailbox, or `PathTaken` when the account already has a folder at that path
 	 */
 	createMailbox = async (
 		input: CreateMailboxQueueInput,
 		accountId: string,
 		subscribe?: boolean,
-	): Promise<MailboxItem> => {
-		// Create local mailbox with pending status
-		const mailbox = await this.mailboxService.create({
+	): Promise<CreateMailboxResult> => {
+		const created = await this.mailboxService.create({
 			...input,
 			syncStatus: MailboxSyncStatus.pending,
 		});
+		if (created.outcome === "PathTaken") return created;
+		const { mailbox } = created;
 
 		this.log.info(
 			{ mailboxId: mailbox.mailboxId, path: mailbox.fullPath },
@@ -149,7 +151,7 @@ export class MailboxQueueService {
 			subscribe,
 		});
 
-		return mailbox;
+		return created;
 	};
 
 	/**

package/src/mailbox-sync.test.ts

@@ -13,7 +13,11 @@ import {
 import { parseImapAttributes } from "./attribute-mapper.js";
 import { type MailboxSyncLogger, MailboxSyncService } from "./mailbox-sync.js";
 
-const silentLogger: MailboxSyncLogger = { info: () => {}, debug: () => {} };
+const silentLogger: MailboxSyncLogger = {
+	info: () => {},
+	debug: () => {},
+	error: () => {},
+};
 
 import type { IImapConnection, ImapNamespaces } from "./types.js";
 
@@ -110,7 +114,10 @@ describe("MailboxSyncService.syncMailboxes — UIDVALIDITY cursor detection (#12
 				return {};
 			},
 			delete: async () => undefined,
-			create: async () => ({}),
+			create: async () => ({
+				outcome: "Created",
+				mailbox: { mailboxId: "new" },
+			}),
 		} as unknown as IMailboxRepository;
 
 		const specialUseService = {
@@ -257,6 +264,7 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			syncStatus?: string;
 			pendingPath?: string;
 		}>,
+		createOutcome: "Created" | "PathTaken" = "Created",
 	) => {
 		const deleted: string[] = [];
 		const created: Array<Record<string, unknown>> = [];
@@ -283,7 +291,11 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 			},
 			create: async (input: Record<string, unknown>) => {
 				created.push(input);
-				return { ...input, mailboxId: `new-${created.length}` };
+				if (createOutcome === "PathTaken") return { outcome: "PathTaken" };
+				return {
+					outcome: "Created",
+					mailbox: { ...input, mailboxId: `new-${created.length}` },
+				};
 			},
 		} as unknown as IMailboxRepository;
 
@@ -401,6 +413,35 @@ describe("MailboxSyncService.syncMailboxes — reconcile does not delete pending
 		assert.deepEqual(deleted, []);
 	});
 
+	it("counts no insert and keeps the account sweep going when the path is already taken", async () => {
+		const { mailboxService, specialUseService, created } = buildServices(
+			[
+				{
+					mailboxId: "inbox",
+					fullPath: "INBOX",
+					syncStatus: MailboxSyncStatus.synced,
+				},
+			],
+			"PathTaken",
+		);
+		const errors: Array<Record<string, unknown>> = [];
+		const service = new MailboxSyncService(mailboxService, specialUseService, {
+			...silentLogger,
+			error: (obj) => {
+				errors.push(obj);
+			},
+		});
+
+		const result = await service.syncMailboxes(
+			{ accountId: "acc-1" },
+			serverConnection([{ fullPath: "INBOX" }, { fullPath: "Projects" }]),
+		);
+
+		assert.equal(created.length, 1);
+		assert.equal(result.created, 0);
+		assert.deepEqual(errors, [{ accountId: "acc-1", fullPath: "Projects" }]);
+	});
+
 	it("lets a failed rename's target be discovered as a folder of its own", async () => {
 		// A failed rename keeps its target so the UI can name what it was aiming
 		// at (T6), and nothing clears it until the user retries or dismisses. If
@@ -539,7 +580,10 @@ describe("MailboxSyncService.syncMailboxes — a lookalike is not a folder the u
 			delete: async (_accountId: string, mailboxId: string) => {
 				deleted.push(mailboxId);
 			},
-			create: async () => ({}),
+			create: async () => ({
+				outcome: "Created",
+				mailbox: { mailboxId: "new" },
+			}),
 		} as unknown as IMailboxRepository;
 
 		const specialUseService = {
@@ -717,7 +761,10 @@ describe("MailboxSyncService.syncMailboxes — a folder leaving mid-sweep (#339)
 				return {};
 			},
 			delete: async () => undefined,
-			create: async () => ({}),
+			create: async () => ({
+				outcome: "Created",
+				mailbox: { mailboxId: "new" },
+			}),
 		} as unknown as IMailboxRepository;
 
 		const specialUseService = {

package/src/mailbox-sync.ts

@@ -82,6 +82,7 @@ export interface SyncAccountInfo {
 export interface MailboxSyncLogger {
 	info(obj: Record<string, unknown>, msg: string): void;
 	debug(obj: Record<string, unknown>, msg: string): void;
+	error(obj: Record<string, unknown>, msg: string): void;
 }
 
 /**
@@ -263,13 +264,13 @@ export class MailboxSyncService {
 						result.updated++;
 					}
 				} else if (!claimedByPendingRename.has(mailboxInfo.fullPath)) {
-					await this.createMailbox(
+					const created = await this.createMailbox(
 						account.accountId,
 						mailboxInfo,
 						namespaces,
 						connection,
 					);
-					result.created++;
+					if (created) result.created++;
 				}
 			},
 			{ concurrency: 3 },
@@ -432,7 +433,7 @@ export class MailboxSyncService {
 		},
 		_namespaces: ImapNamespaces,
 		connection: IImapConnection,
-	): Promise<MailboxItem> => {
+	): Promise<MailboxItem | null> => {
 		// Fetch mailbox status using STATUS command (doesn't require SELECT/EXAMINE)
 		// This gets us message counts including unseen without opening the mailbox
 		const status = await connection.getMailboxStatus(mailboxInfo.fullPath);
@@ -472,7 +473,15 @@ export class MailboxSyncService {
 			// parentMailboxId would need to be resolved from parentPath
 		};
 
-		const mailbox = await this.mailboxService.create(input);
+		const created = await this.mailboxService.create(input);
+		if (created.outcome === "PathTaken") {
+			this.log.error(
+				{ accountId, fullPath: mailboxInfo.fullPath },
+				"Sweep found no row for a folder path the account already holds",
+			);
+			return null;
+		}
+		const { mailbox } = created;
 
 		// Keep the MailboxSpecialUseEntry table in sync — every backend and worker
 		// special-folder lookup reads it through MailboxSpecialUseRepo. Denormalized