@remit/drizzle-service 0.0.50 → 0.0.51

package/package.json

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

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

@@ -1,8 +1,16 @@
 import assert from "node:assert/strict";
 import { randomUUID } from "node:crypto";
 import { after, before, describe, test } from "node:test";
-import { mailboxSpecialUseTable, mailboxTable } from "../schema.js";
+import { composeFolderRoleAppointmentName } from "@remit/data-ports/folder-role";
+import { CanonicalMailboxRole } from "@remit/domain-enums";
+import {
+	accountSettingTable,
+	accountTable,
+	mailboxSpecialUseTable,
+	mailboxTable,
+} from "../schema.js";
 import { createSqliteTestDb } from "../test-db-sqlite.js";
+import { AccountSettingRepo } from "./i4-account-setting.js";
 import { MailboxRepo } from "./i4-mailbox.js";
 import { MailboxSpecialUseRepo } from "./i4-mailbox-special-use.js";
 
@@ -24,27 +32,160 @@ const makeMailboxInput = (accountId: string, fullPath: string) => ({
 	lastMessageSyncAt: Date.now(),
 });
 
-describe("MailboxSpecialUseRepo.findJunkMailbox (sqlite)", () => {
+describe("MailboxSpecialUseRepo role lookups (sqlite)", () => {
 	let close: () => Promise<void>;
 	let repo: MailboxSpecialUseRepo;
 	let mailboxes: MailboxRepo;
+	let accountSettings: AccountSettingRepo;
+	let db: Awaited<ReturnType<typeof createSqliteTestDb>>["db"];
 
 	before(async () => {
 		const testDb = await createSqliteTestDb({
+			account: accountTable,
+			accountSetting: accountSettingTable,
 			mailbox: mailboxTable,
 			mailboxSpecialUse: mailboxSpecialUseTable,
 		});
 		close = testDb.close;
+		db = testDb.db;
 		repo = new MailboxSpecialUseRepo(testDb.db as never);
 		mailboxes = new MailboxRepo(testDb.db as never);
+		accountSettings = new AccountSettingRepo(testDb.db as never);
 	});
 
 	after(async () => {
 		await close();
 	});
 
-	test("resolves an INBOX-nested Junk folder that advertises \\Junk", async () => {
+	const makeAccount = async (): Promise<{
+		accountId: string;
+		accountConfigId: string;
+	}> => {
 		const accountId = randomUUID();
+		const accountConfigId = randomUUID();
+		const now = Date.now();
+		await db.insert(accountTable).values({
+			accountId,
+			accountConfigId,
+			username: `${accountId}@remit.test`,
+			email: `${accountId}@remit.test`,
+			imapHost: "imap.remit.test",
+			imapPort: 993,
+			imapTls: true,
+			imapStartTls: false,
+			isActive: true,
+			connectionState: "authenticated",
+			createdAt: now,
+			updatedAt: now,
+		} as never);
+		return { accountId, accountConfigId };
+	};
+
+	const appoint = (
+		accountConfigId: string,
+		accountId: string,
+		role: (typeof CanonicalMailboxRole)[keyof typeof CanonicalMailboxRole],
+		mailboxId: string,
+	): Promise<unknown> =>
+		accountSettings.upsert({
+			accountConfigId,
+			name: composeFolderRoleAppointmentName(accountId, role),
+			value: { kind: "String", value: mailboxId },
+		});
+
+	test("the appointment beats the folder the server flagged", async () => {
+		const { accountId, accountConfigId } = await makeAccount();
+		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
+		const flagged = await mailboxes.create(makeMailboxInput(accountId, "Junk"));
+		await repo.create(flagged.mailboxId, "Junk");
+		const chosen = await mailboxes.create(
+			makeMailboxInput(accountId, "INBOX/Rubbish"),
+		);
+		await appoint(
+			accountConfigId,
+			accountId,
+			CanonicalMailboxRole.Junk,
+			chosen.mailboxId,
+		);
+
+		const found = await repo.findJunkMailbox(accountId);
+		assert.equal(found?.mailboxId, chosen.mailboxId);
+	});
+
+	test("proposes [Gmail]/Trash beside a top-level Bin, and yields to the appointment", async () => {
+		// #837: joining Trash to the leaf-name resolver made depth outrank the
+		// name, so `Bin` beat `[Gmail]/Trash` and deletes landed in the folder
+		// the user keeps mail in. `bin` is no longer a hint, and an appointment
+		// overrides the proposal either way.
+		const { accountId, accountConfigId } = await makeAccount();
+		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
+		const bin = await mailboxes.create(makeMailboxInput(accountId, "Bin"));
+		const gmailTrash = await mailboxes.create(
+			makeMailboxInput(accountId, "[Gmail]/Trash"),
+		);
+
+		assert.equal(
+			(await repo.findTrashMailbox(accountId))?.mailboxId,
+			gmailTrash.mailboxId,
+		);
+
+		await appoint(
+			accountConfigId,
+			accountId,
+			CanonicalMailboxRole.Trash,
+			bin.mailboxId,
+		);
+		assert.equal(
+			(await repo.findTrashMailbox(accountId))?.mailboxId,
+			bin.mailboxId,
+		);
+	});
+
+	test("an appointment on a mailbox that is gone falls back rather than resolving to nothing", async () => {
+		const { accountId, accountConfigId } = await makeAccount();
+		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
+		const archive = await mailboxes.create(
+			makeMailboxInput(accountId, "INBOX/Archive"),
+		);
+		await appoint(
+			accountConfigId,
+			accountId,
+			CanonicalMailboxRole.Archive,
+			randomUUID(),
+		);
+
+		const found = await repo.findArchiveMailbox(accountId);
+		assert.equal(found?.mailboxId, archive.mailboxId);
+	});
+
+	test("never offers a user folder named Deleted as the Trash to expunge", async () => {
+		// Empty Trash EXPUNGES what this returns. An ordinary folder called
+		// `Deleted` matches the name proposal, and emptying it would destroy mail
+		// the user never put in a trash folder (audit #841).
+		const { accountId, accountConfigId } = await makeAccount();
+		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
+		const keepsakes = await mailboxes.create(
+			makeMailboxInput(accountId, "Deleted"),
+		);
+		const trash = await mailboxes.create(
+			makeMailboxInput(accountId, "[Gmail]/Trash"),
+		);
+
+		assert.equal(await repo.findConfirmedTrashMailbox(accountId), null);
+
+		await appoint(
+			accountConfigId,
+			accountId,
+			CanonicalMailboxRole.Trash,
+			trash.mailboxId,
+		);
+		const confirmed = await repo.findConfirmedTrashMailbox(accountId);
+		assert.equal(confirmed?.mailboxId, trash.mailboxId);
+		assert.notEqual(confirmed?.mailboxId, keepsakes.mailboxId);
+	});
+
+	test("resolves an INBOX-nested Junk folder that advertises \\Junk", async () => {
+		const { accountId } = await makeAccount();
 		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
 		const spam = await mailboxes.create(
 			makeMailboxInput(accountId, "INBOX/Spam"),
@@ -59,7 +200,7 @@ describe("MailboxSpecialUseRepo.findJunkMailbox (sqlite)", () => {
 		// The name fallback used to compare the whole path against a list of
 		// bare names, so `INBOX/Spam` resolved to nothing on a server that
 		// advertises no \Junk.
-		const accountId = randomUUID();
+		const { accountId } = await makeAccount();
 		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
 		const spam = await mailboxes.create(
 			makeMailboxInput(accountId, "INBOX/Spam"),
@@ -70,7 +211,7 @@ describe("MailboxSpecialUseRepo.findJunkMailbox (sqlite)", () => {
 	});
 
 	test("answers null when the account has no Junk folder at all", async () => {
-		const accountId = randomUUID();
+		const { accountId } = await makeAccount();
 		await mailboxes.create(makeMailboxInput(accountId, "INBOX"));
 		await mailboxes.create(makeMailboxInput(accountId, "INBOX/Work"));
 

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

@@ -3,15 +3,27 @@ import type {
 	MailboxSpecialUseItem,
 	MailboxSpecialUseValue,
 } from "@remit/data-ports";
-import { resolveMailboxByLeafName } from "@remit/data-ports/mailbox-name";
-import { JUNK_FOLDER_NAMES } from "@remit/data-ports/mailbox-role";
-import { eq } from "drizzle-orm";
+import {
+	type CanonicalMailboxRoleValue,
+	composeFolderRoleAppointmentName,
+	type RoleMailboxCandidate,
+	resolveConfirmedMailboxForRole,
+	resolveMailboxForRole,
+} from "@remit/data-ports/folder-role";
+import { CanonicalMailboxRole } from "@remit/domain-enums";
+import { eq, inArray } from "drizzle-orm";
 import type { Db } from "../db.js";
 import { randomId } from "../id.js";
+import { accountTable } from "../schema/i4-account-config.js";
 import { mailboxSpecialUseTable, mailboxTable } from "../schema/i4-mailbox.js";
+import { AccountSettingRepo } from "./i4-account-setting.js";
 
 type DB = Db<Record<string, unknown>>;
 
+interface RoleCandidate extends RoleMailboxCandidate {
+	fullPath: string;
+}
+
 function rowToSpecialUse(
 	row: typeof mailboxSpecialUseTable.$inferSelect,
 ): MailboxSpecialUseItem {
@@ -23,7 +35,11 @@ function rowToSpecialUse(
 }
 
 export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
-	constructor(private db: DB) {}
+	private readonly accountSetting: AccountSettingRepo;
+
+	constructor(private db: DB) {
+		this.accountSetting = new AccountSettingRepo(db);
+	}
 
 	async create(
 		mailboxId: string,
@@ -74,92 +90,125 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 		return existing.length;
 	}
 
-	async findBySpecialUse(
+	findInboxMailbox(
 		accountId: string,
-		specialUse: MailboxSpecialUseValue,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		const mailboxes = await this.db
-			.select()
-			.from(mailboxTable)
-			.where(eq(mailboxTable.accountId, accountId));
-
-		for (const mailbox of mailboxes) {
-			const entries = await this.listByMailboxId(mailbox.mailboxId);
-			if (entries.some((e) => e.specialUse === specialUse)) {
-				return { mailboxId: mailbox.mailboxId, fullPath: mailbox.fullPath };
-			}
-		}
-		return null;
+		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Inbox);
 	}
 
-	async findInboxMailbox(
+	findSentMailbox(
 		accountId: string,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		const rows = await this.db
-			.select()
-			.from(mailboxTable)
-			.where(eq(mailboxTable.accountId, accountId));
-		const found = rows.find((r) => r.fullPath.toUpperCase() === "INBOX");
-		return found
-			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
-			: null;
+		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Sent);
 	}
 
-	async findTrashMailbox(
+	findTrashMailbox(
 		accountId: string,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		const bySpecialUse = await this.findBySpecialUse(accountId, "Trash");
-		if (bySpecialUse) return bySpecialUse;
-
-		const rows = await this.db
-			.select()
-			.from(mailboxTable)
-			.where(eq(mailboxTable.accountId, accountId));
+		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Trash);
+	}
 
-		const names = [
-			"trash",
-			"deleted items",
-			"deleted",
-			"[gmail]/trash",
-			"[gmail]/bin",
-		];
-		const found = rows.find((r) => names.includes(r.fullPath.toLowerCase()));
-		return found
-			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
-			: null;
+	findConfirmedTrashMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null> {
+		return this.findMailboxForRole(
+			accountId,
+			CanonicalMailboxRole.Trash,
+			resolveConfirmedMailboxForRole,
+		);
 	}
 
-	async findArchiveMailbox(
+	findArchiveMailbox(
 		accountId: string,
 	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		const bySpecialUse = await this.findBySpecialUse(accountId, "Archive");
-		if (bySpecialUse) return bySpecialUse;
+		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Archive);
+	}
 
-		const rows = await this.db
-			.select()
-			.from(mailboxTable)
-			.where(eq(mailboxTable.accountId, accountId));
+	findJunkMailbox(
+		accountId: string,
+	): Promise<{ mailboxId: string; fullPath: string } | null> {
+		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Junk);
+	}
 
-		const names = ["archive", "archives", "[gmail]/all mail"];
-		const found = rows.find((r) => names.includes(r.fullPath.toLowerCase()));
+	/**
+	 * The one read behind every `find<Role>Mailbox`: the account's mailboxes and
+	 * its appointment for this role, handed to the shared precedence rule. Read
+	 * fresh each time — the appointment is a single indexed row next to reads
+	 * this path already makes, and a cache would leave a role the user just
+	 * re-appointed in the UI pointing at the old folder until it expired.
+	 */
+	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);
 		return found
 			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
 			: null;
 	}
 
-	async findJunkMailbox(
+	/**
+	 * `undefined` whenever the account has no appointment for the role — and
+	 * equally when the account row itself is gone, which is a caller racing a
+	 * delete rather than a reason to fail a lookup the proposal can still answer.
+	 */
+	private async appointedMailboxId(
 		accountId: string,
-	): Promise<{ mailboxId: string; fullPath: string } | null> {
-		const bySpecialUse = await this.findBySpecialUse(accountId, "Junk");
-		if (bySpecialUse) return bySpecialUse;
+		role: CanonicalMailboxRoleValue,
+	): Promise<string | undefined> {
+		const [account] = await this.db
+			.select({ accountConfigId: accountTable.accountConfigId })
+			.from(accountTable)
+			.where(eq(accountTable.accountId, accountId));
+		if (!account) return undefined;
+
+		const setting = await this.accountSetting.get(
+			account.accountConfigId,
+			composeFolderRoleAppointmentName(accountId, role),
+		);
+		if (!setting || setting.value.kind !== "String") return undefined;
+		return setting.value.value;
+	}
 
+	/**
+	 * The account's mailboxes with their SPECIAL-USE designations attached. The
+	 * designations come from `mailboxSpecialUseEntry` rather than the mailbox
+	 * row's denormalized column, because that entry table is what `create` and
+	 * `createMany` here write.
+	 */
+	private async roleCandidates(accountId: string): Promise<RoleCandidate[]> {
 		const rows = await this.db
 			.select()
 			.from(mailboxTable)
 			.where(eq(mailboxTable.accountId, accountId));
-		const found = resolveMailboxByLeafName(rows, JUNK_FOLDER_NAMES);
-		return found
-			? { mailboxId: found.mailboxId, fullPath: found.fullPath }
-			: null;
+		if (rows.length === 0) return [];
+
+		const entries = await this.db
+			.select()
+			.from(mailboxSpecialUseTable)
+			.where(
+				inArray(
+					mailboxSpecialUseTable.mailboxId,
+					rows.map((row) => row.mailboxId),
+				),
+			);
+		const byMailbox = new Map<string, string[]>();
+		for (const entry of entries) {
+			const designations = byMailbox.get(entry.mailboxId) ?? [];
+			designations.push(entry.specialUse);
+			byMailbox.set(entry.mailboxId, designations);
+		}
+
+		return rows.map((row) => ({
+			mailboxId: row.mailboxId,
+			fullPath: row.fullPath,
+			hierarchyDelimiter: row.hierarchyDelimiter,
+			specialUse: byMailbox.get(row.mailboxId) ?? [],
+		}));
 	}
 }