@remit/drizzle-service 0.0.54 → 0.0.56

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/drizzle-service",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "description": "Drizzle ORM service over SQLite",
   "type": "module",
   "main": "src/index.ts",

package/src/repos/i4-mailbox-special-use.sqlite.test.ts

@@ -1,7 +1,10 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { after, before, describe, test } from "node:test";
-import { composeFolderRoleAppointmentName } from "@remit/data-ports/folder-role";
+import {
+	composeFolderRoleAppointmentName,
+	meetsTrashAssurance,
+} from "@remit/data-ports/folder-role";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
 import {
 	accountSettingTable,
@@ -175,7 +178,9 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 			makeMailboxInput(accountId, "[Gmail]/Trash"),
 		);
 
-		assert.equal(await repo.findConfirmedTrashMailbox(accountId), null);
+		const proposal = await repo.resolveTrashRole(accountId);
+		assert.equal(proposal.kind, "proposed");
+		assert.equal(meetsTrashAssurance(proposal, "confirmed"), false);
 
 		await appoint(
 			accountConfigId,
@@ -183,9 +188,50 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 			CanonicalMailboxRole.Trash,
 			trash.mailboxId,
 		);
-		const confirmed = await repo.findConfirmedTrashMailbox(accountId);
-		assert.equal(confirmed?.mailboxId, trash.mailboxId);
-		assert.notEqual(confirmed?.mailboxId, keepsakes.mailboxId);
+		assert.deepEqual(await repo.resolveTrashRole(accountId), {
+			kind: "appointed",
+			mailbox: { mailboxId: trash.mailboxId, fullPath: "[Gmail]/Trash" },
+		});
+		assert.notEqual(trash.mailboxId, keepsakes.mailboxId);
+	});
+
+	test("keeps a stale Trash appointment visible instead of answering the fallback", async () => {
+		// The appointed folder is gone — deleted by another client. `null` and the
+		// flagged folder both hide that; the resolution names the id the user chose
+		// so a refusal can offer the repair (#887).
+		const { accountId, accountConfigId } = await makeAccount();
+		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
+		const flagged = await mailboxes.create(
+			makeMailboxInput(accountId, "[Gmail]/Trash"),
+		);
+		await repo.create(flagged.mailboxId, "Trash");
+		const appointed = randomUUID();
+		await appoint(
+			accountConfigId,
+			accountId,
+			CanonicalMailboxRole.Trash,
+			appointed,
+		);
+
+		assert.deepEqual(await repo.resolveTrashRole(accountId), {
+			kind: "appointment_stale",
+			appointedMailboxId: appointed,
+			fallback: {
+				kind: "flagged",
+				mailbox: { mailboxId: flagged.mailboxId, fullPath: "[Gmail]/Trash" },
+			},
+		});
+
+		// The flagged folder is where a delete files mail, and no evidence at all
+		// that the user meant it to be emptied.
+		assert.equal(
+			meetsTrashAssurance(await repo.resolveTrashRole(accountId), "confirmed"),
+			false,
+		);
+		assert.equal(
+			(await repo.findTrashMailbox(accountId))?.mailboxId,
+			flagged.mailboxId,
+		);
 	});
 
 	test("resolves an INBOX-nested Junk folder that advertises \\Junk", async () => {
@@ -231,7 +277,10 @@ describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 		// Resolving the name widens where a delete FILES mail, never what an
 		// Empty Trash may expunge (#846): that still needs the flag or an
 		// appointment.
-		assert.equal(await repo.findConfirmedTrashMailbox(accountId), null);
+		assert.equal(
+			meetsTrashAssurance(await repo.resolveTrashRole(accountId), "confirmed"),
+			false,
+		);
 	});
 
 	test("resolves an INBOX-nested Archive folder that advertises no special use", async () => {

package/src/repos/i4-mailbox-special-use.structure.test.ts

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { describe, it } from "node:test";
+
+/**
+ * The path a stale appointment last pointed at is a display-only sibling row
+ * (`FolderRoleAppointmentLabel`, #887). "Never read by resolution" is meant to
+ * be structural rather than a habit: this repository composes one setting name
+ * and has no way to reach the other. Read the source to prove it, because the
+ * guarantee is about what the file cannot do, not about what any one call
+ * returns.
+ */
+describe("MailboxSpecialUseRepo and the appointment label row", () => {
+	const source = readFileSync(
+		new URL("./i4-mailbox-special-use.ts", import.meta.url),
+		"utf8",
+	);
+
+	it("never names the label setting", () => {
+		assert.equal(source.includes("FolderRoleAppointmentLabel"), false);
+	});
+
+	it("composes the appointment name in exactly one place", () => {
+		const uses = source.split("composeFolderRoleAppointmentName(").length - 1;
+		assert.equal(uses, 1);
+	});
+});

package/src/repos/i4-mailbox-special-use.ts

@@ -7,8 +7,10 @@ import {
 	type CanonicalMailboxRoleValue,
 	composeFolderRoleAppointmentName,
 	type RoleMailboxCandidate,
-	resolveConfirmedMailboxForRole,
+	type RoleResolution,
 	resolveMailboxForRole,
+	resolveRoleForAccount,
+	type UnappointedRoleResolution,
 } from "@remit/data-ports/folder-role";
 import { CanonicalMailboxRole } from "@remit/domain-enums";
 import { eq, inArray } from "drizzle-orm";
@@ -24,6 +26,39 @@ interface RoleCandidate extends RoleMailboxCandidate {
 	fullPath: string;
 }
 
+interface RoleMailbox {
+	mailboxId: string;
+	fullPath: string;
+}
+
+const projectMailbox = (candidate: RoleCandidate): RoleMailbox => ({
+	mailboxId: candidate.mailboxId,
+	fullPath: candidate.fullPath,
+});
+
+const projectUnappointed = (
+	resolution: UnappointedRoleResolution<RoleCandidate>,
+): UnappointedRoleResolution<RoleMailbox> =>
+	resolution.kind === "none"
+		? resolution
+		: { kind: resolution.kind, mailbox: projectMailbox(resolution.mailbox) };
+
+const projectResolution = (
+	resolution: RoleResolution<RoleCandidate>,
+): RoleResolution<RoleMailbox> => {
+	if (resolution.kind === "appointment_stale") {
+		return {
+			kind: "appointment_stale",
+			appointedMailboxId: resolution.appointedMailboxId,
+			fallback: projectUnappointed(resolution.fallback),
+		};
+	}
+	if (resolution.kind === "appointed") {
+		return { kind: "appointed", mailbox: projectMailbox(resolution.mailbox) };
+	}
+	return projectUnappointed(resolution);
+};
+
 function rowToSpecialUse(
 	row: typeof mailboxSpecialUseTable.$inferSelect,
 ): MailboxSpecialUseItem {
@@ -108,13 +143,21 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Trash);
 	}
 
-	findConfirmedTrashMailbox(
+	/**
+	 * Trash with its evidence, for the verbs that weigh it. Reads exactly what
+	 * `findMailboxForRole` reads — a `null` answer is thrown away there, and this
+	 * keeps it.
+	 */
+	async resolveTrashRole(
 		accountId: string,
-	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		return this.findMailboxForRole(
-			accountId,
-			CanonicalMailboxRole.Trash,
-			resolveConfirmedMailboxForRole,
+	): Promise<RoleResolution<RoleMailbox>> {
+		const role = CanonicalMailboxRole.Trash;
+		const [candidates, appointedMailboxId] = await Promise.all([
+			this.roleCandidates(accountId),
+			this.appointedMailboxId(accountId, role),
+		]);
+		return projectResolution(
+			resolveRoleForAccount(role, candidates, appointedMailboxId),
 		);
 	}
 
@@ -140,13 +183,12 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 	private async findMailboxForRole(
 		accountId: string,
 		role: CanonicalMailboxRoleValue,
-		resolve: typeof resolveMailboxForRole = resolveMailboxForRole,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
 		const [candidates, appointedMailboxId] = await Promise.all([
 			this.roleCandidates(accountId),
 			this.appointedMailboxId(accountId, role),
 		]);
-		const found = resolve(role, candidates, appointedMailboxId);
+		const found = resolveMailboxForRole(role, candidates, appointedMailboxId);
 		return found
 			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
 			: null;