@remit/drizzle-service 0.0.50 → 0.0.52

package/package.json

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

package/src/repos/i4-account-config.ts

@@ -1,8 +1,6 @@
 import type {
 	AccountConfigDescription,
 	AccountConfigItem,
-	AccountItem,
-	AddressItem,
 	CreateAccountConfigInput,
 	IAccountConfigRepository,
 	ResultList,
@@ -18,6 +16,8 @@ import {
 	accountTable,
 } from "../schema/i4-account-config.js";
 import { addressTable } from "../schema/i4-address.js";
+import { rowToAccount } from "./i4-account.js";
+import { rowToAddress } from "./i4-address.js";
 
 type DB = Db<Record<string, unknown>>;
 
@@ -36,62 +36,6 @@ function rowToAccountConfig(
 	};
 }
 
-function rowToAccount(row: typeof accountTable.$inferSelect): AccountItem {
-	return {
-		accountId: row.accountId,
-		accountConfigId: row.accountConfigId,
-		username: row.username,
-		email: row.email,
-		authType: row.authType as AccountItem["authType"],
-		passwordHash: row.passwordHash ?? undefined,
-		oauthRefreshTokenHash: row.oauthRefreshTokenHash ?? undefined,
-		oauthTokenUpdatedAt: row.oauthTokenUpdatedAt ?? undefined,
-		imapHost: row.imapHost,
-		imapPort: row.imapPort,
-		imapTls: row.imapTls,
-		imapStartTls: row.imapStartTls,
-		smtpEnabled: row.smtpEnabled,
-		smtpHost: row.smtpHost,
-		smtpPort: row.smtpPort,
-		smtpTls: row.smtpTls,
-		smtpStartTls: row.smtpStartTls,
-		smtpUsername: row.smtpUsername,
-		smtpPasswordHash: row.smtpPasswordHash ?? undefined,
-		isActive: row.isActive,
-		connectionState: row.connectionState as AccountItem["connectionState"],
-		lastConnectedAt: row.lastConnectedAt ?? undefined,
-		lastSyncAt: row.lastSyncAt ?? undefined,
-		lastError: row.lastError ?? undefined,
-		syncPhase: (row.syncPhase as AccountItem["syncPhase"]) ?? undefined,
-		mailboxCountTotal: row.mailboxCountTotal ?? undefined,
-		mailboxCountSynced: row.mailboxCountSynced ?? undefined,
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt,
-		deletedAt: row.deletedAt ?? undefined,
-	};
-}
-
-function rowToAddress(row: typeof addressTable.$inferSelect): AddressItem {
-	return {
-		addressId: row.addressId,
-		accountConfigId: row.accountConfigId,
-		displayName: row.displayName ?? undefined,
-		localPart: row.localPart,
-		domain: row.domain,
-		normalizedEmail: row.normalizedEmail,
-		normalizedCompound: row.normalizedCompound,
-		flags: (row.flags ?? {}) as AddressItem["flags"],
-		inboundCount: row.inboundCount,
-		outboundCount: row.outboundCount,
-		replyCount: row.replyCount,
-		lastInboundAt: row.lastInboundAt,
-		lastOutboundAt: row.lastOutboundAt ?? undefined,
-		lastReplyAt: row.lastReplyAt,
-		createdAt: row.createdAt,
-		updatedAt: row.updatedAt,
-	};
-}
-
 export class AccountConfigRepo implements IAccountConfigRepository {
 	constructor(private db: DB) {}
 

package/src/repos/i4-address.ts

@@ -10,6 +10,7 @@ import type {
 	UpdateAddressInput,
 } from "@remit/data-ports";
 import { BadRequestError } from "@remit/data-ports/errors";
+import { shouldPromoteWellknown } from "@remit/data-ports/wellknown";
 import {
 	and,
 	asc,
@@ -39,7 +40,6 @@ import {
 	addressRecency,
 	addressSearchMatch,
 } from "./address-search-predicates.js";
-import { shouldPromoteWellknown } from "./i4-address-wellknown.js";
 
 type DB = Db<Record<string, unknown>>;
 

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) ?? [],
+		}));
 	}
 }

package/src/repos/i4-address-wellknown.ts

@@ -1,31 +0,0 @@
-export const WELLKNOWN_INBOUND_THRESHOLD = 3;
-export const WELLKNOWN_REPLY_THRESHOLD = 1;
-export const WELLKNOWN_INBOUND_WINDOW_MS = 90 * 24 * 60 * 60 * 1000;
-
-export interface WellknownEngagementSnapshot {
-	inboundCount?: number;
-	replyCount?: number;
-	lastInboundAt?: number;
-	isBulk?: boolean;
-	flags?: { wellknown?: { value: boolean } | undefined };
-}
-
-export const shouldPromoteWellknown = (
-	snapshot: WellknownEngagementSnapshot,
-	now: number,
-): boolean => {
-	if (snapshot.flags?.wellknown?.value === true) return false;
-
-	const replyCount = snapshot.replyCount ?? 0;
-	const inboundCount = snapshot.inboundCount ?? 0;
-	const replied = replyCount >= WELLKNOWN_REPLY_THRESHOLD;
-	const inboundEnough =
-		!snapshot.isBulk && inboundCount >= WELLKNOWN_INBOUND_THRESHOLD;
-	if (!replied && !inboundEnough) return false;
-
-	const lastInboundAt = snapshot.lastInboundAt;
-	if (lastInboundAt === undefined) return false;
-	if (now - lastInboundAt > WELLKNOWN_INBOUND_WINDOW_MS) return false;
-
-	return true;
-};