@remit/backend 0.0.142 → 0.0.144

package/src/handlers/folder-role-appointments.test.ts

@@ -1,438 +0,0 @@
-import assert from "node:assert/strict";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { describe, it } from "node:test";
-import { fileURLToPath } from "node:url";
-import type { AccountSettingItem } from "@remit/data-ports";
-import type { RoleMailboxCandidate } from "@remit/data-ports/folder-role";
-import {
-	CanonicalMailboxRole,
-	FolderAppointmentSource,
-	MailboxSpecialUse,
-} from "@remit/domain-enums";
-import {
-	CANONICAL_ROLES,
-	groupFolderAppointmentsByAccount,
-	loadFolderAppointmentsForAccount,
-	type PersistedFolderAppointment,
-	resolveFolderAppointments,
-	writeFolderRoleAppointment,
-} from "./folder-role-appointments.js";
-
-const setting = (name: string, value: string): AccountSettingItem =>
-	({
-		accountSettingId: `s-${name}`,
-		accountConfigId: "cfg-1",
-		name,
-		value: { kind: "String", value },
-		createdAt: 0,
-		updatedAt: 0,
-	}) as AccountSettingItem;
-
-const appointed = (
-	mailboxId: string,
-	lastKnownPath?: string,
-): Map<string, PersistedFolderAppointment> =>
-	new Map([[CanonicalMailboxRole.Trash, { mailboxId, lastKnownPath }]]);
-
-describe("CANONICAL_ROLES", () => {
-	it("carries every RFC 032 anchor role, Custom excluded", () => {
-		assert.deepEqual(
-			[...CANONICAL_ROLES].sort(),
-			[
-				CanonicalMailboxRole.Inbox,
-				CanonicalMailboxRole.Drafts,
-				CanonicalMailboxRole.Sent,
-				CanonicalMailboxRole.Archive,
-				CanonicalMailboxRole.Junk,
-				CanonicalMailboxRole.Trash,
-				CanonicalMailboxRole.All,
-				CanonicalMailboxRole.Flagged,
-			].sort(),
-		);
-	});
-});
-
-describe("resolveFolderAppointments", () => {
-	const folders: RoleMailboxCandidate[] = [
-		{ mailboxId: "mb-inbox", fullPath: "INBOX", hierarchyDelimiter: "/" },
-		{
-			mailboxId: "mb-concepten",
-			fullPath: "INBOX/Concepten",
-			hierarchyDelimiter: "/",
-		},
-		{
-			mailboxId: "mb-spam",
-			fullPath: "INBOX/Spam",
-			hierarchyDelimiter: "/",
-			specialUse: [MailboxSpecialUse.Junk],
-		},
-	];
-
-	const roleIn = (
-		result: ReturnType<typeof resolveFolderAppointments>,
-		role: string,
-	) => result.find((entry) => entry.role === role);
-
-	it("carries one entry per canonical role, even when unfilled", () => {
-		const result = resolveFolderAppointments(new Map(), folders);
-		assert.deepEqual(
-			result.map((r) => r.role).sort(),
-			[...CANONICAL_ROLES].sort(),
-		);
-	});
-
-	it("gives every role a source, so no surface has to infer one", () => {
-		const result = resolveFolderAppointments(new Map(), folders);
-		assert.equal(
-			result.every((entry) => entry.source !== undefined),
-			true,
-		);
-	});
-
-	it("tells a folder the user chose from one reader guessed by name", () => {
-		const persisted = new Map<string, PersistedFolderAppointment>([
-			[CanonicalMailboxRole.Drafts, { mailboxId: "mb-concepten" }],
-		]);
-		const result = resolveFolderAppointments(persisted, folders);
-		const drafts = roleIn(result, CanonicalMailboxRole.Drafts);
-		assert.equal(drafts?.mailboxId, "mb-concepten");
-		assert.equal(drafts?.source, FolderAppointmentSource.Appointed);
-
-		const proposed = resolveFolderAppointments(new Map(), folders);
-		const guess = roleIn(proposed, CanonicalMailboxRole.Drafts);
-		assert.equal(guess?.mailboxId, "mb-concepten");
-		assert.equal(guess?.source, FolderAppointmentSource.Proposed);
-	});
-
-	it("marks the server's own flag and the reserved INBOX name as such", () => {
-		const result = resolveFolderAppointments(new Map(), folders);
-		assert.equal(
-			roleIn(result, CanonicalMailboxRole.Junk)?.source,
-			FolderAppointmentSource.Flagged,
-		);
-		assert.equal(
-			roleIn(result, CanonicalMailboxRole.Inbox)?.source,
-			FolderAppointmentSource.Reserved,
-		);
-	});
-
-	it("surfaces a choice whose folder is gone as broken, not as absent", () => {
-		const persisted = new Map<string, PersistedFolderAppointment>([
-			[
-				CanonicalMailboxRole.Junk,
-				{ mailboxId: "mb-deleted-long-ago", lastKnownPath: "INBOX/Rommel" },
-			],
-		]);
-		const junk = roleIn(
-			resolveFolderAppointments(persisted, folders),
-			CanonicalMailboxRole.Junk,
-		);
-		assert.equal(junk?.source, FolderAppointmentSource.Stale);
-		assert.equal(junk?.staleAppointmentMailboxId, "mb-deleted-long-ago");
-		assert.equal(junk?.staleAppointmentPath, "INBOX/Rommel");
-		assert.equal(junk?.mailboxId, "mb-spam");
-	});
-
-	it("leaves a role unfilled when nothing persisted or proposed matches", () => {
-		const archive = roleIn(
-			resolveFolderAppointments(new Map(), folders),
-			CanonicalMailboxRole.Archive,
-		);
-		assert.equal(archive?.mailboxId, undefined);
-		assert.equal(archive?.source, FolderAppointmentSource.None);
-	});
-
-	it("never reads the recorded path as evidence for the role", () => {
-		const trash = roleIn(
-			resolveFolderAppointments(appointed("mb-inbox", "Prullenbak"), folders),
-			CanonicalMailboxRole.Trash,
-		);
-		assert.equal(trash?.mailboxId, "mb-inbox");
-		assert.equal(trash?.staleAppointmentPath, undefined);
-	});
-});
-
-describe("groupFolderAppointmentsByAccount", () => {
-	it("groups by accountId then role from the composite setting name", () => {
-		const settings = [
-			setting(
-				`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Drafts}`,
-				"mb-1",
-			),
-			setting(
-				`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Sent}`,
-				"mb-2",
-			),
-			setting(
-				`FolderRoleAppointment#acc-2#${CanonicalMailboxRole.Inbox}`,
-				"mb-3",
-			),
-			setting("AccountDisplayName#acc-1", "Alice"),
-		];
-		const grouped = groupFolderAppointmentsByAccount(settings);
-		assert.deepEqual(Object.fromEntries(grouped.get("acc-1") ?? []), {
-			[CanonicalMailboxRole.Drafts]: { mailboxId: "mb-1" },
-			[CanonicalMailboxRole.Sent]: { mailboxId: "mb-2" },
-		});
-		assert.deepEqual(Object.fromEntries(grouped.get("acc-2") ?? []), {
-			[CanonicalMailboxRole.Inbox]: { mailboxId: "mb-3" },
-		});
-	});
-
-	it("attaches the recorded path to the appointment it belongs to", () => {
-		const settings = [
-			setting(
-				`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Trash}`,
-				"mb-1",
-			),
-			setting(
-				`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Trash}`,
-				"INBOX/Bak",
-			),
-			setting(
-				`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Sent}`,
-				"INBOX/Verzonden",
-			),
-		];
-		const grouped = groupFolderAppointmentsByAccount(settings);
-		assert.deepEqual(Object.fromEntries(grouped.get("acc-1") ?? []), {
-			[CanonicalMailboxRole.Trash]: {
-				mailboxId: "mb-1",
-				lastKnownPath: "INBOX/Bak",
-			},
-		});
-	});
-
-	it("ignores a leftover MailboxRole#<mailboxId> row instead of throwing", () => {
-		// The #963/#964 backfill wrote `MailboxRole#<mailboxId>` rows that are no
-		// longer written but still persist in production. `FolderRoleAppointment`
-		// superseded `MailboxRole` (RFC 032 exclusive-folder-appointment, #976);
-		// a leftover row alongside real appointments must not make GET /config
-		// throw — it is simply not a folder-role appointment and gets skipped.
-		const settings = [
-			setting(
-				`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Drafts}`,
-				"mb-1",
-			),
-			setting("MailboxRole#mb-legacy", "custom"),
-		];
-		const grouped = groupFolderAppointmentsByAccount(settings);
-		assert.deepEqual(Object.fromEntries(grouped.get("acc-1") ?? []), {
-			[CanonicalMailboxRole.Drafts]: { mailboxId: "mb-1" },
-		});
-	});
-});
-
-describe("loadFolderAppointmentsForAccount", () => {
-	const readerOver = (stored: Map<string, string>) => ({
-		get: async (_accountConfigId: string, name: string) => {
-			const value = stored.get(name);
-			return value ? setting(name, value) : null;
-		},
-	});
-
-	it("reads each role's row and collects only the ones that exist", async () => {
-		const roles = await loadFolderAppointmentsForAccount(
-			readerOver(
-				new Map([
-					[
-						`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Sent}`,
-						"mb-sent",
-					],
-				]),
-			),
-			"cfg-1",
-			"acc-1",
-		);
-		assert.deepEqual(Object.fromEntries(roles), {
-			[CanonicalMailboxRole.Sent]: { mailboxId: "mb-sent" },
-		});
-	});
-
-	it("picks up the recorded path beside the appointment", async () => {
-		const roles = await loadFolderAppointmentsForAccount(
-			readerOver(
-				new Map([
-					[
-						`FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Trash}`,
-						"mb-bak",
-					],
-					[
-						`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Trash}`,
-						"INBOX/Bak",
-					],
-				]),
-			),
-			"cfg-1",
-			"acc-1",
-		);
-		assert.deepEqual(roles.get(CanonicalMailboxRole.Trash), {
-			mailboxId: "mb-bak",
-			lastKnownPath: "INBOX/Bak",
-		});
-	});
-
-	it("drops a label left behind by an appointment that was cleared", async () => {
-		const roles = await loadFolderAppointmentsForAccount(
-			readerOver(
-				new Map([
-					[
-						`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Trash}`,
-						"INBOX/Bak",
-					],
-				]),
-			),
-			"cfg-1",
-			"acc-1",
-		);
-		assert.equal(roles.get(CanonicalMailboxRole.Trash), undefined);
-	});
-});
-
-describe("writeFolderRoleAppointment", () => {
-	const recorder = () => {
-		const upserts: unknown[] = [];
-		const deletes: unknown[][] = [];
-		return {
-			upserts,
-			deletes,
-			accountSetting: {
-				upsert: async (input: unknown) => {
-					upserts.push(input);
-					return input as never;
-				},
-				delete: async (accountConfigId: string, name: string) => {
-					deletes.push([accountConfigId, name]);
-				},
-			},
-		};
-	};
-
-	it("records the path alongside the appointment", async () => {
-		const { upserts, deletes, accountSetting } = recorder();
-		await writeFolderRoleAppointment(
-			accountSetting,
-			"cfg-1",
-			"acc-1",
-			CanonicalMailboxRole.Archive,
-			"mb-archive",
-			"INBOX/Archief",
-		);
-		assert.deepEqual(upserts, [
-			{
-				accountConfigId: "cfg-1",
-				name: `FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Archive}`,
-				value: { kind: "String", value: "mb-archive" },
-			},
-			{
-				accountConfigId: "cfg-1",
-				name: `FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Archive}`,
-				value: { kind: "String", value: "INBOX/Archief" },
-			},
-		]);
-		assert.deepEqual(deletes, []);
-	});
-
-	it("clears a path left over from the previous choice", async () => {
-		const { upserts, deletes, accountSetting } = recorder();
-		await writeFolderRoleAppointment(
-			accountSetting,
-			"cfg-1",
-			"acc-1",
-			CanonicalMailboxRole.Archive,
-			"mb-archive",
-		);
-		assert.equal(upserts.length, 1);
-		assert.deepEqual(deletes, [
-			[
-				"cfg-1",
-				`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Archive}`,
-			],
-		]);
-	});
-
-	it("deletes both rows when the appointment is cleared", async () => {
-		const { upserts, deletes, accountSetting } = recorder();
-		await writeFolderRoleAppointment(
-			accountSetting,
-			"cfg-1",
-			"acc-1",
-			CanonicalMailboxRole.Archive,
-			null,
-		);
-		assert.deepEqual(upserts, []);
-		assert.deepEqual(deletes, [
-			["cfg-1", `FolderRoleAppointment#acc-1#${CanonicalMailboxRole.Archive}`],
-			[
-				"cfg-1",
-				`FolderRoleAppointmentLabel#acc-1#${CanonicalMailboxRole.Archive}`,
-			],
-		]);
-	});
-});
-
-/**
- * D1 of the #887 design: a folder-role appointment row means one thing — a
- * person decided. That is what makes an appointment outrank the server's own
- * \Trash flag, and what makes an Empty Trash on one defensible. It holds only
- * while the row has a single author, so the author is pinned here rather than
- * left to review.
- */
-describe("who may write a folder-role appointment", () => {
-	const PACKAGES = fileURLToPath(new URL("../../../", import.meta.url));
-
-	const sourceFiles = (): string[] => {
-		const files: string[] = [];
-		for (const pkg of readdirSync(PACKAGES, { withFileTypes: true })) {
-			if (!pkg.isDirectory()) continue;
-			const src = join(PACKAGES, pkg.name, "src");
-			if (!existsSync(src)) continue;
-			for (const entry of readdirSync(src, { recursive: true })) {
-				const name = String(entry);
-				if (!name.endsWith(".ts") && !name.endsWith(".tsx")) continue;
-				if (name.endsWith(".test.ts") || name.endsWith(".test.tsx")) continue;
-				files.push(`${pkg.name}/src/${name}`);
-			}
-		}
-		return files;
-	};
-
-	it("is composed in three places, and nowhere else in the repo", () => {
-		const referrers = sourceFiles().filter((file) =>
-			readFileSync(join(PACKAGES, file), "utf8").includes(
-				"composeFolderRoleAppointmentName",
-			),
-		);
-		assert.deepEqual(referrers.sort(), [
-			"backend/src/handlers/folder-role-appointments.ts",
-			"data-ports/src/folder-role.ts",
-			"drizzle-service/src/repos/i4-mailbox-special-use.ts",
-		]);
-	});
-
-	it("is written by writeFolderRoleAppointment alone", () => {
-		const source = readFileSync(
-			fileURLToPath(new URL("./folder-role-appointments.ts", import.meta.url)),
-			"utf8",
-		);
-		const writer = source.slice(
-			source.indexOf("export const writeFolderRoleAppointment"),
-		);
-		const body = writer.slice(0, writer.indexOf("\n};"));
-
-		const count = (text: string, needle: string) =>
-			text.split(needle).length - 1;
-		// Without these, renaming the receiver satisfies the guard with 0 === 0.
-		assert.ok(count(body, "accountSetting.upsert(") > 0);
-		assert.ok(count(body, "accountSetting.delete(") > 0);
-		assert.equal(
-			count(source, "accountSetting.upsert("),
-			count(body, "accountSetting.upsert("),
-		);
-		assert.equal(
-			count(source, "accountSetting.delete("),
-			count(body, "accountSetting.delete("),
-		);
-	});
-});

package/src/handlers/folder-role-appointments.ts

@@ -1,249 +0,0 @@
-import type { FolderAppointment } from "@remit/api-openapi-types";
-import type {
-	AccountSettingItem,
-	IAccountSettingRepository,
-	IMailboxRepository,
-} from "@remit/data-ports";
-import {
-	CANONICAL_ROLES,
-	type CanonicalMailboxRoleValue,
-	composeFolderRoleAppointmentLabelName,
-	composeFolderRoleAppointmentName,
-	parseFolderRoleAppointmentLabelName,
-	parseFolderRoleAppointmentName,
-	type RoleMailboxCandidate,
-	type RoleResolution,
-	resolveRoleForAccount,
-} from "@remit/data-ports/folder-role";
-import { FolderAppointmentSource } from "@remit/domain-enums";
-
-/**
- * RFC 032 exclusive-folder-appointment (#976): a per-account role→mailbox map.
- * Each row is a `FolderRoleAppointment#<accountId>#<role>` AccountSetting (RFC
- * 032 settings tiers), so a role can never be persisted twice for one account —
- * writing it replaces whichever mailbox previously held it. This module owns
- * that persistence; the read side is `resolveRoleForAccount`
- * (`@remit/data-ports/folder-role`), the same rule every special-folder lookup
- * in the backend and the workers goes through.
- *
- * A second row, `FolderRoleAppointmentLabel#<accountId>#<role>`, records the
- * path the appointed mailbox had at the time (#887), so a folder another client
- * later deletes can still be named back to the user. It is display only: it
- * lives beside the appointment rather than inside it precisely so the
- * repository that resolves roles composes one name and cannot reach the other.
- */
-
-export { CANONICAL_ROLES };
-
-/** One role's persisted appointment: the choice, plus the path it was made on. */
-export interface PersistedFolderAppointment {
-	mailboxId: string;
-	lastKnownPath?: string;
-}
-
-const stringValueOf = (item: AccountSettingItem): string | undefined => {
-	const { value } = item;
-	return value.kind === "String" ? value.value : undefined;
-};
-
-/**
- * Group every persisted folder-role appointment in one config-wide settings
- * read (e.g. GET /config's already-loaded `listByAccountConfig` result) by
- * accountId, then by role. Mirrors `groupAccountOverrides` / `groupMailboxOverrides`.
- */
-export const groupFolderAppointmentsByAccount = (
-	settings: AccountSettingItem[],
-): Map<string, Map<string, PersistedFolderAppointment>> => {
-	const byAccount = new Map<string, Map<string, PersistedFolderAppointment>>();
-
-	for (const setting of settings) {
-		const target = parseFolderRoleAppointmentName(setting.name);
-		if (!target) continue;
-		const mailboxId = stringValueOf(setting);
-		if (mailboxId === undefined) continue;
-		const roles =
-			byAccount.get(target.accountId) ??
-			new Map<string, PersistedFolderAppointment>();
-		roles.set(target.role, { mailboxId });
-		byAccount.set(target.accountId, roles);
-	}
-
-	for (const setting of settings) {
-		const target = parseFolderRoleAppointmentLabelName(setting.name);
-		if (!target) continue;
-		const lastKnownPath = stringValueOf(setting);
-		if (lastKnownPath === undefined) continue;
-		const appointment = byAccount.get(target.accountId)?.get(target.role);
-		if (!appointment) continue;
-		appointment.lastKnownPath = lastKnownPath;
-	}
-
-	return byAccount;
-};
-
-/**
- * Load one account's persisted appointments by reading each role's row
- * directly (mirrors `loadMailboxOverrides`'s three-get pattern). Used by the
- * create/update account handlers, which only ever need a single account.
- */
-export const loadFolderAppointmentsForAccount = async (
-	accountSetting: Pick<IAccountSettingRepository, "get">,
-	accountConfigId: string,
-	accountId: string,
-): Promise<Map<string, PersistedFolderAppointment>> => {
-	const entries = await Promise.all(
-		CANONICAL_ROLES.map(async (role) => {
-			const appointment = await accountSetting.get(
-				accountConfigId,
-				composeFolderRoleAppointmentName(accountId, role),
-			);
-			const mailboxId = appointment ? stringValueOf(appointment) : undefined;
-			if (mailboxId === undefined) return [role, undefined] as const;
-
-			const label = await accountSetting.get(
-				accountConfigId,
-				composeFolderRoleAppointmentLabelName(accountId, role),
-			);
-			const lastKnownPath = label ? stringValueOf(label) : undefined;
-			return [
-				role,
-				lastKnownPath === undefined
-					? { mailboxId }
-					: { mailboxId, lastKnownPath },
-			] as const;
-		}),
-	);
-	const roles = new Map<string, PersistedFolderAppointment>();
-	for (const [role, appointment] of entries) {
-		if (appointment) roles.set(role, appointment);
-	}
-	return roles;
-};
-
-/**
- * Persist (or clear) one role's appointment. `mailboxId: null` deletes the row
- * — the role goes back to unfilled (RFC 032 settings tiers: absence is unset).
- * A value upserts it, replacing whatever mailbox the role pointed at before;
- * there is no second row a duplicate could live in.
- *
- * The label row moves with it, so a path recorded for a previous choice can
- * never be shown against the current one.
- */
-export const writeFolderRoleAppointment = async (
-	accountSetting: Pick<IAccountSettingRepository, "upsert" | "delete">,
-	accountConfigId: string,
-	accountId: string,
-	role: CanonicalMailboxRoleValue,
-	mailboxId: string | null,
-	lastKnownPath?: string,
-): Promise<void> => {
-	const name = composeFolderRoleAppointmentName(accountId, role);
-	const labelName = composeFolderRoleAppointmentLabelName(accountId, role);
-
-	if (mailboxId === null) {
-		await accountSetting.delete(accountConfigId, name);
-		await accountSetting.delete(accountConfigId, labelName);
-		return;
-	}
-
-	await accountSetting.upsert({
-		accountConfigId,
-		name,
-		value: { kind: "String", value: mailboxId },
-	});
-
-	if (lastKnownPath === undefined) {
-		await accountSetting.delete(accountConfigId, labelName);
-		return;
-	}
-	await accountSetting.upsert({
-		accountConfigId,
-		name: labelName,
-		value: { kind: "String", value: lastKnownPath },
-	});
-};
-
-const SOURCE_BY_KIND: Record<
-	"appointed" | "flagged" | "reserved" | "proposed",
-	FolderAppointment["source"]
-> = {
-	appointed: FolderAppointmentSource.Appointed,
-	flagged: FolderAppointmentSource.Flagged,
-	reserved: FolderAppointmentSource.Reserved,
-	proposed: FolderAppointmentSource.Proposed,
-};
-
-const toFolderAppointment = (
-	role: CanonicalMailboxRoleValue,
-	resolution: RoleResolution<RoleMailboxCandidate>,
-	lastKnownPath: string | undefined,
-): FolderAppointment => {
-	if (resolution.kind === "appointment_stale") {
-		const { fallback } = resolution;
-		return {
-			role,
-			source: FolderAppointmentSource.Stale,
-			mailboxId:
-				fallback.kind === "none" ? undefined : fallback.mailbox.mailboxId,
-			staleAppointmentMailboxId: resolution.appointedMailboxId,
-			staleAppointmentPath: lastKnownPath,
-		};
-	}
-	if (resolution.kind === "none") {
-		return { role, source: FolderAppointmentSource.None };
-	}
-	return {
-		role,
-		source: SOURCE_BY_KIND[resolution.kind],
-		mailboxId: resolution.mailbox.mailboxId,
-	};
-};
-
-/**
- * Resolve the full appointment set for one account, each entry saying where it
- * came from: the user's persisted choice when set, else the server's
- * SPECIAL-USE flag, else the reserved INBOX name, else a name proposal. A
- * choice naming a mailbox the account no longer holds resolves to whatever the
- * account would have had without it, and says so — the user's decision is
- * surfaced as broken rather than quietly discarded. Always one entry per
- * `CANONICAL_ROLES` member (RFC 032 settings tiers: total, never a sparse
- * array).
- */
-export const resolveFolderAppointments = (
-	persisted: ReadonlyMap<string, PersistedFolderAppointment>,
-	mailboxes: readonly RoleMailboxCandidate[],
-): FolderAppointment[] =>
-	CANONICAL_ROLES.map((role) => {
-		const appointment = persisted.get(role);
-		return toFolderAppointment(
-			role,
-			resolveRoleForAccount(role, mailboxes, appointment?.mailboxId),
-			appointment?.lastKnownPath,
-		);
-	});
-
-/**
- * End-to-end resolution for one account: load its persisted appointments and
- * its mailboxes, then resolve. The single entry point every handler that
- * builds an AccountResponse calls (create/update account, GET /config's
- * per-account fan-out mirrors this with a pre-loaded settings batch instead —
- * see `groupFolderAppointmentsByAccount` — to avoid an N+1 settings read).
- */
-export const resolveAccountFolderAppointments = async (
-	client: {
-		mailbox: Pick<IMailboxRepository, "listAllByAccount">;
-		accountSetting: Pick<IAccountSettingRepository, "get">;
-	},
-	accountConfigId: string,
-	accountId: string,
-): Promise<FolderAppointment[]> => {
-	const [persisted, mailboxes] = await Promise.all([
-		loadFolderAppointmentsForAccount(
-			client.accountSetting,
-			accountConfigId,
-			accountId,
-		),
-		client.mailbox.listAllByAccount(accountId),
-	]);
-	return resolveFolderAppointments(persisted, mailboxes);
-};