@remit/web-client 0.0.193 → 0.0.194

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/web-client",
-  "version": "0.0.193",
+  "version": "0.0.194",
   "type": "module",
   "description": "Remit web client, published as composable primitives — the app shell, auth shells, and runtime config. A distributor imports what it composes and bundles it.",
   "exports": {

package/src/lib/delete-folder.test.ts

@@ -2,7 +2,6 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import {
 	advanceMove,
-	appointedRole,
 	beginMove,
 	excludeFolder,
 	type FolderNode,
@@ -11,6 +10,7 @@ import {
 	hasChildFolders,
 	initialStage,
 	moveProgressLabel,
+	vouchedRole,
 } from "./delete-folder.js";
 
 const folder = (
@@ -36,13 +36,74 @@ describe("guardFolderDeletion", () => {
 		const guard = guardFolderDeletion(
 			target,
 			[target],
-			[{ role: "Archive", mailboxId: "arch" }],
+			[{ role: "Archive", source: "Appointed", mailboxId: "arch" }],
 		);
 		assert.equal(guard.deletable, false);
 		assert.equal(guard.reason, "role");
 		assert.match(guard.message ?? "", /Archive/);
 	});
 
+	it("blocks a folder the mail server flagged for the role", () => {
+		const target = folder({ mailboxId: "sent", fullPath: "Sent" });
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Sent", source: "Flagged", mailboxId: "sent" }],
+		);
+		assert.equal(guard.deletable, false);
+		assert.equal(guard.reason, "role");
+	});
+
+	it("deletes a folder whose only role claim is a name proposal", () => {
+		const target = folder({ mailboxId: "arch", fullPath: "Archive" });
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Archive", source: "Proposed", mailboxId: "arch" }],
+		);
+		assert.deepEqual(guard, { deletable: true });
+	});
+
+	it("deletes the name-proposed fallback a stale appointment resolves to", () => {
+		const target = folder({ mailboxId: "deleted-items", fullPath: "Deleted" });
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Trash", source: "Stale", mailboxId: "deleted-items" }],
+		);
+		assert.deepEqual(guard, { deletable: true });
+	});
+
+	it("blocks the flagged folder a stale appointment falls back to", () => {
+		const target = folder({
+			mailboxId: "server-trash",
+			fullPath: "Trash",
+			specialUse: ["Trash"],
+		});
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Trash", source: "Stale", mailboxId: "server-trash" }],
+		);
+		assert.equal(guard.deletable, false);
+		assert.equal(guard.reason, "role");
+		assert.match(guard.message ?? "", /Trash/);
+	});
+
+	it("reads the flag for the role the entry names, not any flag the folder has", () => {
+		const target = folder({
+			mailboxId: "archive",
+			fullPath: "Archive",
+			specialUse: ["Archive"],
+		});
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Trash", source: "Stale", mailboxId: "archive" }],
+		);
+		assert.deepEqual(guard, { deletable: true });
+	});
+
 	it("blocks a folder that has subfolders", () => {
 		const target = folder({ mailboxId: "work", fullPath: "Work" });
 		const child = folder({ mailboxId: "sub", fullPath: "Work/Shop" });
@@ -62,14 +123,18 @@ describe("guardFolderDeletion", () => {
 		const guard = guardFolderDeletion(
 			target,
 			[target, other],
-			[{ role: "Archive", mailboxId: "other-box" }],
+			[{ role: "Archive", source: "Appointed", mailboxId: "other-box" }],
 		);
 		assert.deepEqual(guard, { deletable: true });
 	});
 
 	it("ignores an unfilled role appointment with no mailbox", () => {
 		const target = folder({ mailboxId: "r", fullPath: "Receipts" });
-		const guard = guardFolderDeletion(target, [target], [{ role: "Junk" }]);
+		const guard = guardFolderDeletion(
+			target,
+			[target],
+			[{ role: "Junk", source: "None" }],
+		);
 		assert.equal(guard.deletable, true);
 	});
 });
@@ -106,20 +171,42 @@ describe("hasChildFolders", () => {
 	});
 });
 
-describe("appointedRole", () => {
+describe("vouchedRole", () => {
 	it("returns the role a mailbox fills", () => {
 		assert.equal(
-			appointedRole("a", [{ role: "Trash", mailboxId: "a" }]),
+			vouchedRole({ mailboxId: "a" }, [
+				{ role: "Trash", source: "Appointed", mailboxId: "a" },
+			]),
 			"Trash",
 		);
 	});
 
 	it("returns undefined when the mailbox fills no role", () => {
 		assert.equal(
-			appointedRole("a", [{ role: "Trash", mailboxId: "b" }]),
+			vouchedRole({ mailboxId: "a" }, [
+				{ role: "Trash", source: "Appointed", mailboxId: "b" },
+			]),
+			undefined,
+		);
+	});
+
+	it("returns undefined for a role nobody vouched for", () => {
+		assert.equal(
+			vouchedRole({ mailboxId: "a" }, [
+				{ role: "Trash", source: "Proposed", mailboxId: "a" },
+			]),
 			undefined,
 		);
 	});
+
+	it("returns the role a stale entry falls back to when the server flags it", () => {
+		assert.equal(
+			vouchedRole({ mailboxId: "a", specialUse: ["Trash"] }, [
+				{ role: "Trash", source: "Stale", mailboxId: "a" },
+			]),
+			"Trash",
+		);
+	});
 });
 
 describe("excludeFolder", () => {

package/src/lib/delete-folder.ts

@@ -1,3 +1,5 @@
+import type { RemitImapFolderAppointment } from "@remit/api-http-client/types.gen.ts";
+
 export const MOVE_BATCH_SIZE = 100;
 
 export interface FolderNode {
@@ -5,10 +7,16 @@ export interface FolderNode {
 	fullPath: string;
 	hierarchyDelimiter: string;
 	messageCount: number;
+	/** RFC 6154 SPECIAL-USE flags, bare (`Trash`, not `\Trash`). */
+	specialUse?: readonly string[];
 }
 
+/** Where a role's answer came from. */
+export type RoleAppointmentSource = RemitImapFolderAppointment["source"];
+
 export interface RoleAppointment {
 	role: string;
+	source: RoleAppointmentSource;
 	mailboxId?: string | null;
 }
 
@@ -39,18 +47,48 @@ export const hasChildFolders = (
 	);
 };
 
-/** The canonical role a mailbox is appointed to, or `undefined` when unfilled. */
-export const appointedRole = (
-	mailboxId: string,
+/**
+ * Sources that vouch for the mailbox they name: a person chose it, or the
+ * server flagged it. `Proposed` is a guess at a folder's name and vouches for
+ * nothing. `Reserved` is unreachable behind the inbox branch below and stays
+ * anyway — this set is a statement about evidence, not about branch order.
+ */
+const VOUCHED_SOURCES: readonly RoleAppointmentSource[] = [
+	"Appointed",
+	"Flagged",
+	"Reserved",
+];
+
+/**
+ * A `Stale` entry resolves to whatever the account would have had with no
+ * appointment at all, and that fallback can be the folder the server itself
+ * flags for the role. The entry no longer carries which it was, so read the
+ * flag off the folder: the mail server's designation is unchanged by the
+ * user's own choice going missing, and nothing behind this guard re-checks it.
+ * Flag values are the bare RFC 6154 names, identical to the canonical roles.
+ */
+const vouchesFor = (
+	appointment: RoleAppointment,
+	folder: Pick<FolderNode, "mailboxId" | "specialUse">,
+): boolean => {
+	if (appointment.mailboxId !== folder.mailboxId) return false;
+	if (appointment.source === "Stale")
+		return folder.specialUse?.includes(appointment.role) ?? false;
+	return VOUCHED_SOURCES.includes(appointment.source);
+};
+
+/** The canonical role a folder is vouched for, or `undefined` when none is. */
+export const vouchedRole = (
+	folder: Pick<FolderNode, "mailboxId" | "specialUse">,
 	appointments: readonly RoleAppointment[],
-): string | undefined =>
-	appointments.find((a) => a.mailboxId != null && a.mailboxId === mailboxId)
-		?.role;
+): string | undefined => appointments.find((a) => vouchesFor(a, folder))?.role;
 
 /**
  * Why a folder can't be deleted, or `{ deletable: true }` when it can. The
- * inbox is reserved, a folder that fills a canonical role must be released
- * first, and a folder with subfolders must have them handled before it goes.
+ * inbox is reserved, a folder somebody vouched for in a canonical role must be
+ * released first, and a folder with subfolders must have them handled before it
+ * goes. A role a folder only fills because its name reads that way is no reason
+ * to keep the folder: the message would name a remedy that does not apply.
  */
 export function guardFolderDeletion(
 	folder: FolderNode,
@@ -64,7 +102,7 @@ export function guardFolderDeletion(
 			message: "The inbox can't be deleted.",
 		};
 
-	const role = appointedRole(folder.mailboxId, appointments);
+	const role = vouchedRole(folder, appointments);
 	if (role)
 		return {
 			deletable: false,