@remit/backend 0.0.74 → 0.0.76

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.74",
+  "version": "0.0.76",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

package/src/handlers/folder-role.test.ts

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AccountSettingItem, MailboxItem } from "@remit/data-ports";
+import { isPublicApiError } from "@remit/data-ports/errors";
+import { composeFolderRoleAppointmentLabelName } from "@remit/data-ports/folder-role";
+import { CanonicalMailboxRole, MailboxSyncStatus } from "@remit/domain-enums";
+import { assertMailboxSettled } from "./folder-role.js";
+import { applyMailboxPatch, type MailboxPatchClient } from "./mailbox.js";
+
+const mailbox = (over: Partial<MailboxItem>): MailboxItem =>
+	({
+		mailboxId: "mb-1",
+		fullPath: "INBOX/Prullenbak",
+		hierarchyDelimiter: "/",
+		...over,
+	}) as unknown as MailboxItem;
+
+const caught = (run: () => void): unknown => {
+	let thrown: unknown;
+	assert.throws(run, (error: unknown) => {
+		thrown = error;
+		return true;
+	});
+	return thrown;
+};
+
+const publicErrorOf = (error: unknown) => {
+	if (typeof error !== "object" || error === null) return undefined;
+	const { publicApiError } = error as { publicApiError?: unknown };
+	return isPublicApiError(publicApiError) ? publicApiError : undefined;
+};
+
+describe("assertMailboxSettled", () => {
+	it("refuses a folder the mail server has not created yet", () => {
+		const error = caught(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.pending })),
+		);
+		assert.equal(publicErrorOf(error)?.code, "mailbox_not_settled");
+	});
+
+	it("refuses a folder on its way out", () => {
+		const error = caught(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.deleting })),
+		);
+		assert.equal(publicErrorOf(error)?.code, "mailbox_not_settled");
+	});
+
+	it("carries the mailbox and its state, so the client words a wait", () => {
+		const error = caught(() =>
+			assertMailboxSettled(
+				mailbox({ mailboxId: "mb-9", syncStatus: MailboxSyncStatus.pending }),
+			),
+		);
+		assert.deepEqual(publicErrorOf(error)?.details, {
+			mailboxId: "mb-9",
+			syncStatus: "pending",
+		});
+	});
+
+	it("allows a settled folder, and one whose delete failed", () => {
+		assert.doesNotThrow(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.synced })),
+		);
+		assert.doesNotThrow(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.failed })),
+		);
+		assert.doesNotThrow(() => assertMailboxSettled(mailbox({})));
+	});
+});
+
+describe("applyMailboxPatch — the appointment label follows a rename", () => {
+	const labelName = composeFolderRoleAppointmentLabelName(
+		"acc-1",
+		CanonicalMailboxRole.Trash,
+	);
+	const sentLabelName = composeFolderRoleAppointmentLabelName(
+		"acc-1",
+		CanonicalMailboxRole.Sent,
+	);
+	const appointmentName = (role: string) =>
+		`FolderRoleAppointment#acc-1#${role}`;
+
+	const settingsFor = (
+		rows: Record<string, string>,
+		renamed = "INBOX",
+	): { store: Record<string, string>; client: MailboxPatchClient } => {
+		const store: Record<string, string> = { ...rows };
+		const client = {
+			mailbox: {
+				get: async () => mailbox({ fullPath: renamed }),
+			},
+			mailboxQueue: {
+				renameMailbox: async (mailboxId: string, newPath: string) =>
+					mailbox({ mailboxId, fullPath: newPath }),
+			},
+			accountSetting: {
+				get: async (_configId: string, name: string) =>
+					store[name] === undefined
+						? undefined
+						: ({
+								name,
+								value: { kind: "String", value: store[name] },
+							} as AccountSettingItem),
+				upsert: async (item: AccountSettingItem) => {
+					if (item.value.kind === "String") store[item.name] = item.value.value;
+					return item;
+				},
+				delete: async (_configId: string, name: string) => {
+					delete store[name];
+				},
+			},
+		} as unknown as MailboxPatchClient;
+		return { store, client };
+	};
+
+	it("rewrites the recorded path for the folder that was renamed", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-1",
+				[labelName]: "INBOX/Prullenbak",
+			},
+			"INBOX/Prullenbak",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "INBOX/Verwijderd",
+		});
+
+		assert.equal(store[labelName], "INBOX/Verwijderd");
+	});
+
+	// IMAP RENAME moves the subtree in one command and `renameChildPaths`
+	// rewrites every descendant row, so every label under the branch moves too.
+	it("carries every appointed folder under the renamed branch with it", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "INBOX/Prullenbak",
+				[appointmentName(CanonicalMailboxRole.Sent)]: "mb-sent",
+				[sentLabelName]: "INBOX/Verzonden",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "Mail/Prullenbak");
+		assert.equal(store[sentLabelName], "Mail/Verzonden");
+	});
+
+	it("leaves a folder outside the renamed branch alone", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "Archief/Prullenbak",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "Archief/Prullenbak");
+	});
+
+	it("never rebases a sibling that merely shares the prefix", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "INBOXES/Prullenbak",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "INBOXES/Prullenbak");
+	});
+});

package/src/handlers/folder-role.ts

@@ -2,6 +2,9 @@ import type {
 	AppointFolderRoleInput,
 	CanonicalMailboxRole,
 } from "@remit/api-openapi-types";
+import type { MailboxItem } from "@remit/data-ports";
+import { MailboxNotSettledError } from "@remit/data-ports/errors";
+import { MailboxSyncStatus } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import { getAccountConfigIdFromEvent } from "../auth.js";
 import { getClient } from "../service/data-client.js";
@@ -16,6 +19,30 @@ import {
 } from "./folder-role-appointments.js";
 import { assertMailboxInAccount } from "./mailbox.js";
 
+/** Mailbox states in which the mail server has not settled the folder yet. */
+const UNSETTLED: ReadonlySet<string> = new Set([
+	MailboxSyncStatus.pending,
+	MailboxSyncStatus.deleting,
+]);
+
+/**
+ * Appointing a role to a folder the mail server is still creating or deleting
+ * would bind the account's Trash to a folder that may never exist (D16 item 3,
+ * imap-mutations R2: wait). A `\Noselect` container is refused by construction
+ * — mailbox-sync keeps no row for one — so there is nothing to appoint.
+ */
+export const assertMailboxSettled = (
+	target: Pick<MailboxItem, "mailboxId" | "fullPath" | "syncStatus">,
+): void => {
+	const syncStatus = target.syncStatus;
+	if (!syncStatus || !UNSETTLED.has(syncStatus)) return;
+	throw new MailboxNotSettledError(
+		`Mailbox ${target.fullPath} is not settled on the mail server yet`,
+		target.mailboxId,
+		syncStatus,
+	);
+};
+
 /**
  * RFC 032 exclusive-folder-appointment (#976): the single write operation for
  * the per-account role map. `appoint(role, mailboxId)` sets `map[role]` —
@@ -47,6 +74,7 @@ export const FolderRoleOperations: Record<
 		if (body.mailboxId) {
 			const target = await mailbox.get(accountId, body.mailboxId);
 			assertMailboxInAccount(target, accountId, "act");
+			assertMailboxSettled(target);
 			lastKnownPath = target.fullPath;
 		}
 

package/src/handlers/mailbox.test.ts

@@ -1,8 +1,17 @@
 import assert from "node:assert/strict";
-import { describe, it } from "node:test";
+import { afterEach, describe, it } from "node:test";
 import type { MailboxItem } from "@remit/data-ports";
 import { MailboxSyncStatus } from "@remit/domain-enums";
-import { excludeDeletingMailboxes } from "./mailbox.js";
+import { UnconfirmedTrashMailboxError } from "@remit/mailbox-service";
+import type { APIGatewayProxyEvent } from "aws-lambda";
+import type { Context } from "openapi-backend";
+import { deriveAccountConfigId } from "../auth.js";
+import {
+	_resetForTest,
+	type RemitClient,
+	setClient,
+} from "../service/data-client.js";
+import { excludeDeletingMailboxes, TrashOperations } from "./mailbox.js";
 
 const mailbox = (
 	over: Partial<MailboxItem> & { mailboxId: string },
@@ -32,3 +41,58 @@ describe("excludeDeletingMailboxes", () => {
 		);
 	});
 });
+
+const SUB = "cognito-sub-887";
+const ACCOUNT_ID = "acc-887";
+
+const emptyTrash = TrashOperations.TrashOperations_emptyTrash as unknown as (
+	context: Context,
+	event: APIGatewayProxyEvent,
+) => Promise<{ deletedCount: number }>;
+
+const callEmptyTrash = (
+	serviceEmptyTrash: () => Promise<{ deletedCount: number }>,
+): Promise<{ deletedCount: number }> => {
+	setClient({
+		account: {
+			get: async () => ({
+				accountId: ACCOUNT_ID,
+				accountConfigId: deriveAccountConfigId(SUB),
+			}),
+		},
+		messageMove: { emptyTrash: serviceEmptyTrash },
+	} as unknown as RemitClient);
+
+	return emptyTrash(
+		{ request: { params: { accountId: ACCOUNT_ID } } } as unknown as Context,
+		{
+			requestContext: { authorizer: { claims: { sub: SUB } } },
+		} as unknown as APIGatewayProxyEvent,
+	);
+};
+
+describe("TrashOperations_emptyTrash", () => {
+	afterEach(() => {
+		_resetForTest();
+	});
+
+	it("reports the service's count rather than one of its own", async () => {
+		// The handler resolves no folder and counts no rows: a second read would
+		// be free to disagree with the one that actually marked them.
+		const response = await callEmptyTrash(async () => ({ deletedCount: 7 }));
+
+		assert.deepEqual(response, { deletedCount: 7 });
+	});
+
+	it("lets the service's coded refusal through untouched", async () => {
+		await assert.rejects(
+			callEmptyTrash(async () => {
+				throw new UnconfirmedTrashMailboxError(ACCOUNT_ID);
+			}),
+			(error: unknown) =>
+				error instanceof UnconfirmedTrashMailboxError &&
+				error.statusCode === 409 &&
+				error.publicApiError?.details?.reason === "unconfirmed",
+		);
+	});
+});

package/src/handlers/mailbox.ts

@@ -4,8 +4,11 @@ import type {
 } from "@remit/api-openapi-types";
 import type { IAccountSettingRepository, MailboxItem } from "@remit/data-ports";
 import { ForbiddenError, NotFoundError } from "@remit/data-ports/errors";
+import {
+	type CanonicalMailboxRoleValue,
+	composeFolderRoleAppointmentLabelName,
+} from "@remit/data-ports/folder-role";
 import { MailboxSyncStatus, MessageSystemFlag } from "@remit/domain-enums";
-import { NoTrashMailboxError } from "@remit/mailbox-service";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import { getAccountConfigIdFromEvent } from "../auth.js";
 import {
@@ -26,6 +29,7 @@ import {
 	type MailboxOverrides,
 } from "./account-overrides.js";
 import { assertAccountOwnership } from "./account-ownership.js";
+import { loadFolderAppointmentsForAccount } from "./folder-role-appointments.js";
 
 /**
  * The mute flag and the display-name override are user preferences that live
@@ -69,9 +73,73 @@ export interface MailboxPatchClient {
 			accountId: string,
 		): Promise<MailboxItem>;
 	};
-	accountSetting: Pick<IAccountSettingRepository, "upsert" | "delete">;
+	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
 }
 
+/**
+ * Where a recorded path lands after the rename, or `undefined` when the rename
+ * did not move it. IMAP RENAME moves the whole subtree in one command and
+ * `renameChildPaths` rewrites every descendant row with it, so a label under
+ * the renamed branch moves exactly as far as its prefix does.
+ */
+const rebasePath = (
+	recorded: string,
+	oldPath: string,
+	newPath: string,
+	delimiter: string,
+): string | undefined => {
+	if (recorded === oldPath) return newPath;
+	const branch = `${oldPath}${delimiter}`;
+	if (!recorded.startsWith(branch)) return undefined;
+	return `${newPath}${recorded.slice(oldPath.length)}`;
+};
+
+/**
+ * A reader-side rename keeps every mailboxId, so the appointments survive it —
+ * but the paths recorded beside them (#887) would still name where the folders
+ * were before. Move the labels with the branch, or a later third-party delete
+ * names a path the user has not seen since the rename.
+ *
+ * The renamed folder is matched by id; its descendants are matched by the path
+ * each label already holds, which is the path their rows carried until this
+ * rename rewrote them.
+ */
+const refreshAppointmentLabels = async (
+	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert">,
+	accountConfigId: string,
+	accountId: string,
+	renamed: { mailboxId: string; oldPath: string; newPath: string },
+	delimiter: string,
+): Promise<void> => {
+	const persisted = await loadFolderAppointmentsForAccount(
+		accountSetting,
+		accountConfigId,
+		accountId,
+	);
+	for (const [role, appointment] of persisted) {
+		const moved =
+			appointment.mailboxId === renamed.mailboxId
+				? renamed.newPath
+				: appointment.lastKnownPath === undefined
+					? undefined
+					: rebasePath(
+							appointment.lastKnownPath,
+							renamed.oldPath,
+							renamed.newPath,
+							delimiter,
+						);
+		if (moved === undefined || moved === appointment.lastKnownPath) continue;
+		await accountSetting.upsert({
+			accountConfigId,
+			name: composeFolderRoleAppointmentLabelName(
+				accountId,
+				role as CanonicalMailboxRoleValue,
+			),
+			value: { kind: "String", value: moved },
+		});
+	}
+};
+
 /**
  * Apply a mailbox PATCH body: override changes first (mute flag + display-name/
  * role overrides — written to per-mailbox AccountSetting rows, no IMAP
@@ -110,7 +178,26 @@ export const applyMailboxPatch = async (
 		return client.mailbox.get(accountId, mailboxId);
 	}
 
-	return client.mailboxQueue.renameMailbox(mailboxId, fullPath, accountId);
+	// Read before the rename: the labels of the folders under this one are
+	// rebased off the path it is leaving, which the row no longer carries after.
+	const before = await client.mailbox.get(accountId, mailboxId);
+	const renamed = await client.mailboxQueue.renameMailbox(
+		mailboxId,
+		fullPath,
+		accountId,
+	);
+	await refreshAppointmentLabels(
+		client.accountSetting,
+		accountConfigId,
+		accountId,
+		{
+			mailboxId,
+			oldPath: before.fullPath,
+			newPath: renamed.fullPath,
+		},
+		before.hierarchyDelimiter,
+	);
+	return renamed;
 };
 
 /**
@@ -412,26 +499,10 @@ export const TrashOperations: Record<
 		const account = await client.account.get(accountId);
 		assertAccountOwnership(account, accountConfigId, "act");
 
-		// The same confirmed resolution `emptyTrash` expunges through, so the
-		// count reported is the count of the folder that gets emptied. It
-		// refuses rather than returning zero when no folder is appointed and
-		// none is flagged: "0 deleted" reads as success, and the user goes on
-		// believing their Trash is empty.
-		const trashMailbox =
-			await client.mailboxSpecialUse.findConfirmedTrashMailbox(accountId);
-
-		if (!trashMailbox) {
-			throw new NoTrashMailboxError(accountId);
-		}
-
-		const messages = await client.message.listAllByMailbox(
-			trashMailbox.mailboxId,
-		);
-		const deletedCount = messages.length;
-
-		// MessageMoveService handles: Message status updates + SQS event
-		await client.messageMove.emptyTrash(accountConfigId, accountId);
-
-		return { deletedCount };
+		// The service resolves Trash, marks the rows and counts them, all off one
+		// read, and refuses with a coded 409 when the role is unresolved. Counting
+		// here as well would be a second answer free to disagree with the one that
+		// acts, and "0 deleted" reads as success to a user whose Trash is untouched.
+		return client.messageMove.emptyTrash(accountConfigId, accountId);
 	},
 };