@remit/drizzle-service 0.0.63 → 0.0.65

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

@@ -6,6 +6,7 @@ import type {
 import {
 	type CanonicalMailboxRoleValue,
 	composeFolderRoleAppointmentName,
+	type JunkRoleMailboxes,
 	type RoleMailboxCandidate,
 	type RoleResolution,
 	resolveMailboxForRole,
@@ -22,6 +23,23 @@ import { AccountSettingRepo } from "./i4-account-setting.js";
 
 type DB = Db<Record<string, unknown>>;
 
+const JUNK_ROLES: readonly CanonicalMailboxRoleValue[] = [
+	CanonicalMailboxRole.Junk,
+	CanonicalMailboxRole.Trash,
+];
+
+const appointmentKey = (
+	accountId: string,
+	role: CanonicalMailboxRoleValue,
+): string => `${accountId}\u0000${role}`;
+
+// The only place this repository names an appointment setting, so that no read
+// here can reach the display-only label row sitting beside it (#887).
+const appointmentSettingName = (
+	accountId: string,
+	role: CanonicalMailboxRoleValue,
+): string => composeFolderRoleAppointmentName(accountId, role);
+
 interface RoleCandidate extends RoleMailboxCandidate {
 	fullPath: string;
 }
@@ -173,6 +191,148 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 		return this.findMailboxForRole(accountId, CanonicalMailboxRole.Junk);
 	}
 
+	/**
+	 * Junk and Trash for every account under one config, in a fixed number of
+	 * reads however many accounts the config holds — this feeds a predicate the
+	 * per-message reconcile runs inside the sync loop.
+	 */
+	async resolveJunkRolesForConfig(
+		accountConfigId: string,
+	): Promise<JunkRoleMailboxes> {
+		const accounts = await this.db
+			.select({ accountId: accountTable.accountId })
+			.from(accountTable)
+			.where(eq(accountTable.accountConfigId, accountConfigId));
+		return this.resolveJunkRoles(accounts.map((row) => row.accountId));
+	}
+
+	/**
+	 * The same answer for every account the instance holds. A mailbox id belongs
+	 * to exactly one account, so a union across accounts is no less selective
+	 * than asking each of them separately — which is what lets the boot sweep
+	 * run one pass over the address table instead of one per config.
+	 */
+	async resolveJunkRolesForInstance(): Promise<JunkRoleMailboxes> {
+		const accounts = await this.db
+			.select({ accountId: accountTable.accountId })
+			.from(accountTable);
+		return this.resolveJunkRoles(accounts.map((row) => row.accountId));
+	}
+
+	private async resolveJunkRoles(
+		accountIds: readonly string[],
+	): Promise<JunkRoleMailboxes> {
+		if (accountIds.length === 0) {
+			return { junkMailboxIds: [], trashMailboxIds: [] };
+		}
+		const [candidates, appointments] = await Promise.all([
+			this.roleCandidatesFor(accountIds),
+			this.appointedMailboxIds(accountIds, JUNK_ROLES),
+		]);
+
+		const junkMailboxIds: string[] = [];
+		const trashMailboxIds: string[] = [];
+		for (const accountId of accountIds) {
+			const mailboxes = candidates.get(accountId) ?? [];
+			const junk = resolveMailboxForRole(
+				CanonicalMailboxRole.Junk,
+				mailboxes,
+				appointments.get(appointmentKey(accountId, CanonicalMailboxRole.Junk)),
+			);
+			if (junk) junkMailboxIds.push(junk.mailboxId);
+			const trash = resolveMailboxForRole(
+				CanonicalMailboxRole.Trash,
+				mailboxes,
+				appointments.get(appointmentKey(accountId, CanonicalMailboxRole.Trash)),
+			);
+			if (trash) trashMailboxIds.push(trash.mailboxId);
+		}
+		return { junkMailboxIds, trashMailboxIds };
+	}
+
+	/**
+	 * Each account's appointment for each role, in two reads. Same precedence
+	 * input as `appointedMailboxId`, batched: an account row missing is a caller
+	 * racing a delete, and leaves the account with no appointment rather than
+	 * failing the lookup.
+	 */
+	private async appointedMailboxIds(
+		accountIds: readonly string[],
+		roles: readonly CanonicalMailboxRoleValue[],
+	): Promise<Map<string, string>> {
+		const accounts = await this.db
+			.select({
+				accountId: accountTable.accountId,
+				accountConfigId: accountTable.accountConfigId,
+			})
+			.from(accountTable)
+			.where(inArray(accountTable.accountId, [...accountIds]));
+		if (accounts.length === 0) return new Map();
+
+		const wanted = new Map<string, string>();
+		for (const account of accounts) {
+			for (const role of roles) {
+				wanted.set(
+					appointmentSettingName(account.accountId, role),
+					appointmentKey(account.accountId, role),
+				);
+			}
+		}
+
+		const settings = await this.accountSetting.getMany(
+			accounts.map((account) => account.accountConfigId),
+			[...wanted.keys()],
+		);
+
+		const appointed = new Map<string, string>();
+		for (const setting of settings) {
+			const key = wanted.get(setting.name);
+			if (!key) continue;
+			if (setting.value.kind !== "String") continue;
+			appointed.set(key, setting.value.value);
+		}
+		return appointed;
+	}
+
+	private async roleCandidatesFor(
+		accountIds: readonly string[],
+	): Promise<Map<string, RoleCandidate[]>> {
+		const rows = await this.db
+			.select()
+			.from(mailboxTable)
+			.where(inArray(mailboxTable.accountId, [...accountIds]));
+		if (rows.length === 0) return new Map();
+
+		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);
+		}
+
+		const byAccount = new Map<string, RoleCandidate[]>();
+		for (const row of rows) {
+			const candidates = byAccount.get(row.accountId) ?? [];
+			candidates.push({
+				mailboxId: row.mailboxId,
+				fullPath: row.fullPath,
+				hierarchyDelimiter: row.hierarchyDelimiter,
+				specialUse: byMailbox.get(row.mailboxId) ?? [],
+			});
+			byAccount.set(row.accountId, candidates);
+		}
+		return byAccount;
+	}
+
 	/**
 	 * 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
@@ -211,7 +371,7 @@ export class MailboxSpecialUseRepo implements IMailboxSpecialUseRepository {
 
 		const setting = await this.accountSetting.get(
 			account.accountConfigId,
-			composeFolderRoleAppointmentName(accountId, role),
+			appointmentSettingName(accountId, role),
 		);
 		if (!setting || setting.value.kind !== "String") return undefined;
 		return setting.value.value;

package/src/repos/i4-outbox-message.test.ts

@@ -105,6 +105,52 @@ describe("OutboxMessageRepo", () => {
 		await repo.delete(accountConfigId, msg.outboxMessageId);
 	});
 
+	test("updateIfStatus writes on the expected status and refuses any other", async () => {
+		const accountConfigId = randomId();
+		const msg = await repo.create(makeOutboxInput(randomId(), accountConfigId));
+
+		const written = await repo.updateIfStatus(
+			accountConfigId,
+			msg.outboxMessageId,
+			"queued",
+			{ status: "failed", lastError: "the queue refused it" },
+		);
+		assert.equal(written?.status, "failed");
+
+		// The compare-and-set every outbox transition rests on: a caller that read
+		// `queued` and decided on it must not overwrite a row the worker has since
+		// moved. `null` says another writer got there first.
+		const refused = await repo.updateIfStatus(
+			accountConfigId,
+			msg.outboxMessageId,
+			"queued",
+			{ status: "draft" },
+		);
+		assert.equal(refused, null);
+		const still = await repo.get(accountConfigId, msg.outboxMessageId);
+		assert.equal(still.status, "failed");
+
+		await repo.delete(accountConfigId, msg.outboxMessageId);
+	});
+
+	test("cross-tenant: updateIfStatus refuses a foreign accountConfig", async () => {
+		const accountConfigId = randomId();
+		const other = randomId();
+		const msg = await repo.create(makeOutboxInput(randomId(), accountConfigId));
+
+		const refused = await repo.updateIfStatus(
+			other,
+			msg.outboxMessageId,
+			"queued",
+			{ status: "failed" },
+		);
+		assert.equal(refused, null);
+		const still = await repo.get(accountConfigId, msg.outboxMessageId);
+		assert.equal(still.status, "queued");
+
+		await repo.delete(accountConfigId, msg.outboxMessageId);
+	});
+
 	test("markSent clears lastError and lastSmtpCode", async () => {
 		const accountConfigId = randomId();
 		const msg = await repo.create({

package/src/repos/i4-outbox-message.ts

@@ -129,6 +129,40 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 		outboxMessageId: string,
 		input: UpdateOutboxMessageInput,
 	): Promise<OutboxMessageItem> {
+		const [row] = await this.applyUpdate(
+			accountConfigId,
+			outboxMessageId,
+			input,
+		);
+		if (!row)
+			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
+		return rowToOutboxMessage(row);
+	}
+
+	async updateIfStatus(
+		accountConfigId: string,
+		outboxMessageId: string,
+		expected: OutboxMessageItem["status"],
+		input: UpdateOutboxMessageInput,
+	): Promise<OutboxMessageItem | null> {
+		const [row] = await this.applyUpdate(
+			accountConfigId,
+			outboxMessageId,
+			input,
+			expected,
+		);
+		// No row means the status moved or the row went away — both say another
+		// writer got there first, which is the caller's answer rather than an
+		// error here.
+		return row ? rowToOutboxMessage(row) : null;
+	}
+
+	private async applyUpdate(
+		accountConfigId: string,
+		outboxMessageId: string,
+		input: UpdateOutboxMessageInput,
+		expected?: OutboxMessageItem["status"],
+	): Promise<(typeof outboxMessageTable.$inferSelect)[]> {
 		const now = Date.now();
 		const updates: Partial<typeof outboxMessageTable.$inferInsert> = {
 			updatedAt: now,
@@ -154,19 +188,20 @@ export class OutboxMessageRepo implements IOutboxMessageRepository {
 		if (input.inReplyTo !== undefined) updates.inReplyTo = input.inReplyTo;
 		if (input.references !== undefined) updates.references = input.references;
 
-		const [row] = await this.db
+		const rows = await this.db
 			.update(outboxMessageTable)
 			.set(updates)
 			.where(
 				and(
 					eq(outboxMessageTable.accountConfigId, accountConfigId),
 					eq(outboxMessageTable.outboxMessageId, outboxMessageId),
+					expected === undefined
+						? undefined
+						: eq(outboxMessageTable.status, expected),
 				),
 			)
 			.returning();
-		if (!row)
-			throw new NotFoundError(`OutboxMessage not found: ${outboxMessageId}`);
-		return rowToOutboxMessage(row);
+		return rows;
 	}
 
 	async updateStatus(