@remit/backend 0.0.75 → 0.0.77

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/backend",
-  "version": "0.0.75",
+  "version": "0.0.77",
   "description": "Remit Mail Inspector API backend",
   "license": "MIT",
   "author": "",

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

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { AccountSettingItem, MailboxItem } from "@remit/data-ports";
+import { isPublicApiError } from "@remit/data-ports/errors";
+import { composeFolderRoleAppointmentLabelName } from "@remit/data-ports/folder-role";
+import { CanonicalMailboxRole, MailboxSyncStatus } from "@remit/domain-enums";
+import { assertMailboxSettled } from "./folder-role.js";
+import { applyMailboxPatch, type MailboxPatchClient } from "./mailbox.js";
+
+const mailbox = (over: Partial<MailboxItem>): MailboxItem =>
+	({
+		mailboxId: "mb-1",
+		fullPath: "INBOX/Prullenbak",
+		hierarchyDelimiter: "/",
+		...over,
+	}) as unknown as MailboxItem;
+
+const caught = (run: () => void): unknown => {
+	let thrown: unknown;
+	assert.throws(run, (error: unknown) => {
+		thrown = error;
+		return true;
+	});
+	return thrown;
+};
+
+const publicErrorOf = (error: unknown) => {
+	if (typeof error !== "object" || error === null) return undefined;
+	const { publicApiError } = error as { publicApiError?: unknown };
+	return isPublicApiError(publicApiError) ? publicApiError : undefined;
+};
+
+describe("assertMailboxSettled", () => {
+	it("refuses a folder the mail server has not created yet", () => {
+		const error = caught(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.pending })),
+		);
+		assert.equal(publicErrorOf(error)?.code, "mailbox_not_settled");
+	});
+
+	it("refuses a folder on its way out", () => {
+		const error = caught(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.deleting })),
+		);
+		assert.equal(publicErrorOf(error)?.code, "mailbox_not_settled");
+	});
+
+	it("carries the mailbox and its state, so the client words a wait", () => {
+		const error = caught(() =>
+			assertMailboxSettled(
+				mailbox({ mailboxId: "mb-9", syncStatus: MailboxSyncStatus.pending }),
+			),
+		);
+		assert.deepEqual(publicErrorOf(error)?.details, {
+			mailboxId: "mb-9",
+			syncStatus: "pending",
+		});
+	});
+
+	it("allows a settled folder, and one whose delete failed", () => {
+		assert.doesNotThrow(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.synced })),
+		);
+		assert.doesNotThrow(() =>
+			assertMailboxSettled(mailbox({ syncStatus: MailboxSyncStatus.failed })),
+		);
+		assert.doesNotThrow(() => assertMailboxSettled(mailbox({})));
+	});
+});
+
+describe("applyMailboxPatch — the appointment label follows a rename", () => {
+	const labelName = composeFolderRoleAppointmentLabelName(
+		"acc-1",
+		CanonicalMailboxRole.Trash,
+	);
+	const sentLabelName = composeFolderRoleAppointmentLabelName(
+		"acc-1",
+		CanonicalMailboxRole.Sent,
+	);
+	const appointmentName = (role: string) =>
+		`FolderRoleAppointment#acc-1#${role}`;
+
+	const settingsFor = (
+		rows: Record<string, string>,
+		renamed = "INBOX",
+	): { store: Record<string, string>; client: MailboxPatchClient } => {
+		const store: Record<string, string> = { ...rows };
+		const client = {
+			mailbox: {
+				get: async () => mailbox({ fullPath: renamed }),
+			},
+			mailboxQueue: {
+				renameMailbox: async (mailboxId: string, newPath: string) =>
+					mailbox({ mailboxId, fullPath: newPath }),
+			},
+			accountSetting: {
+				get: async (_configId: string, name: string) =>
+					store[name] === undefined
+						? undefined
+						: ({
+								name,
+								value: { kind: "String", value: store[name] },
+							} as AccountSettingItem),
+				upsert: async (item: AccountSettingItem) => {
+					if (item.value.kind === "String") store[item.name] = item.value.value;
+					return item;
+				},
+				delete: async (_configId: string, name: string) => {
+					delete store[name];
+				},
+			},
+		} as unknown as MailboxPatchClient;
+		return { store, client };
+	};
+
+	it("rewrites the recorded path for the folder that was renamed", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-1",
+				[labelName]: "INBOX/Prullenbak",
+			},
+			"INBOX/Prullenbak",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "INBOX/Verwijderd",
+		});
+
+		assert.equal(store[labelName], "INBOX/Verwijderd");
+	});
+
+	// IMAP RENAME moves the subtree in one command and `renameChildPaths`
+	// rewrites every descendant row, so every label under the branch moves too.
+	it("carries every appointed folder under the renamed branch with it", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "INBOX/Prullenbak",
+				[appointmentName(CanonicalMailboxRole.Sent)]: "mb-sent",
+				[sentLabelName]: "INBOX/Verzonden",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "Mail/Prullenbak");
+		assert.equal(store[sentLabelName], "Mail/Verzonden");
+	});
+
+	it("leaves a folder outside the renamed branch alone", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "Archief/Prullenbak",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "Archief/Prullenbak");
+	});
+
+	it("never rebases a sibling that merely shares the prefix", async () => {
+		const { store, client } = settingsFor(
+			{
+				[appointmentName(CanonicalMailboxRole.Trash)]: "mb-trash",
+				[labelName]: "INBOXES/Prullenbak",
+			},
+			"INBOX",
+		);
+
+		await applyMailboxPatch(client, "cfg-1", "mb-1", "acc-1", {
+			fullPath: "Mail",
+		});
+
+		assert.equal(store[labelName], "INBOXES/Prullenbak");
+	});
+});

package/src/handlers/folder-role.ts

@@ -2,6 +2,9 @@ import type {
 	AppointFolderRoleInput,
 	CanonicalMailboxRole,
 } from "@remit/api-openapi-types";
+import type { MailboxItem } from "@remit/data-ports";
+import { MailboxNotSettledError } from "@remit/data-ports/errors";
+import { MailboxSyncStatus } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import { getAccountConfigIdFromEvent } from "../auth.js";
 import { getClient } from "../service/data-client.js";
@@ -16,6 +19,30 @@ import {
 } from "./folder-role-appointments.js";
 import { assertMailboxInAccount } from "./mailbox.js";
 
+/** Mailbox states in which the mail server has not settled the folder yet. */
+const UNSETTLED: ReadonlySet<string> = new Set([
+	MailboxSyncStatus.pending,
+	MailboxSyncStatus.deleting,
+]);
+
+/**
+ * Appointing a role to a folder the mail server is still creating or deleting
+ * would bind the account's Trash to a folder that may never exist (D16 item 3,
+ * imap-mutations R2: wait). A `\Noselect` container is refused by construction
+ * — mailbox-sync keeps no row for one — so there is nothing to appoint.
+ */
+export const assertMailboxSettled = (
+	target: Pick<MailboxItem, "mailboxId" | "fullPath" | "syncStatus">,
+): void => {
+	const syncStatus = target.syncStatus;
+	if (!syncStatus || !UNSETTLED.has(syncStatus)) return;
+	throw new MailboxNotSettledError(
+		`Mailbox ${target.fullPath} is not settled on the mail server yet`,
+		target.mailboxId,
+		syncStatus,
+	);
+};
+
 /**
  * RFC 032 exclusive-folder-appointment (#976): the single write operation for
  * the per-account role map. `appoint(role, mailboxId)` sets `map[role]` —
@@ -47,6 +74,7 @@ export const FolderRoleOperations: Record<
 		if (body.mailboxId) {
 			const target = await mailbox.get(accountId, body.mailboxId);
 			assertMailboxInAccount(target, accountId, "act");
+			assertMailboxSettled(target);
 			lastKnownPath = target.fullPath;
 		}
 

package/src/handlers/mailbox.ts

@@ -4,6 +4,10 @@ import type {
 } from "@remit/api-openapi-types";
 import type { IAccountSettingRepository, MailboxItem } from "@remit/data-ports";
 import { ForbiddenError, NotFoundError } from "@remit/data-ports/errors";
+import {
+	type CanonicalMailboxRoleValue,
+	composeFolderRoleAppointmentLabelName,
+} from "@remit/data-ports/folder-role";
 import { MailboxSyncStatus, MessageSystemFlag } from "@remit/domain-enums";
 import type { APIGatewayProxyEvent } from "aws-lambda";
 import { getAccountConfigIdFromEvent } from "../auth.js";
@@ -25,6 +29,7 @@ import {
 	type MailboxOverrides,
 } from "./account-overrides.js";
 import { assertAccountOwnership } from "./account-ownership.js";
+import { loadFolderAppointmentsForAccount } from "./folder-role-appointments.js";
 
 /**
  * The mute flag and the display-name override are user preferences that live
@@ -68,9 +73,73 @@ export interface MailboxPatchClient {
 			accountId: string,
 		): Promise<MailboxItem>;
 	};
-	accountSetting: Pick<IAccountSettingRepository, "upsert" | "delete">;
+	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert" | "delete">;
 }
 
+/**
+ * Where a recorded path lands after the rename, or `undefined` when the rename
+ * did not move it. IMAP RENAME moves the whole subtree in one command and
+ * `renameChildPaths` rewrites every descendant row with it, so a label under
+ * the renamed branch moves exactly as far as its prefix does.
+ */
+const rebasePath = (
+	recorded: string,
+	oldPath: string,
+	newPath: string,
+	delimiter: string,
+): string | undefined => {
+	if (recorded === oldPath) return newPath;
+	const branch = `${oldPath}${delimiter}`;
+	if (!recorded.startsWith(branch)) return undefined;
+	return `${newPath}${recorded.slice(oldPath.length)}`;
+};
+
+/**
+ * A reader-side rename keeps every mailboxId, so the appointments survive it —
+ * but the paths recorded beside them (#887) would still name where the folders
+ * were before. Move the labels with the branch, or a later third-party delete
+ * names a path the user has not seen since the rename.
+ *
+ * The renamed folder is matched by id; its descendants are matched by the path
+ * each label already holds, which is the path their rows carried until this
+ * rename rewrote them.
+ */
+const refreshAppointmentLabels = async (
+	accountSetting: Pick<IAccountSettingRepository, "get" | "upsert">,
+	accountConfigId: string,
+	accountId: string,
+	renamed: { mailboxId: string; oldPath: string; newPath: string },
+	delimiter: string,
+): Promise<void> => {
+	const persisted = await loadFolderAppointmentsForAccount(
+		accountSetting,
+		accountConfigId,
+		accountId,
+	);
+	for (const [role, appointment] of persisted) {
+		const moved =
+			appointment.mailboxId === renamed.mailboxId
+				? renamed.newPath
+				: appointment.lastKnownPath === undefined
+					? undefined
+					: rebasePath(
+							appointment.lastKnownPath,
+							renamed.oldPath,
+							renamed.newPath,
+							delimiter,
+						);
+		if (moved === undefined || moved === appointment.lastKnownPath) continue;
+		await accountSetting.upsert({
+			accountConfigId,
+			name: composeFolderRoleAppointmentLabelName(
+				accountId,
+				role as CanonicalMailboxRoleValue,
+			),
+			value: { kind: "String", value: moved },
+		});
+	}
+};
+
 /**
  * Apply a mailbox PATCH body: override changes first (mute flag + display-name/
  * role overrides — written to per-mailbox AccountSetting rows, no IMAP
@@ -109,7 +178,26 @@ export const applyMailboxPatch = async (
 		return client.mailbox.get(accountId, mailboxId);
 	}
 
-	return client.mailboxQueue.renameMailbox(mailboxId, fullPath, accountId);
+	// Read before the rename: the labels of the folders under this one are
+	// rebased off the path it is leaving, which the row no longer carries after.
+	const before = await client.mailbox.get(accountId, mailboxId);
+	const renamed = await client.mailboxQueue.renameMailbox(
+		mailboxId,
+		fullPath,
+		accountId,
+	);
+	await refreshAppointmentLabels(
+		client.accountSetting,
+		accountConfigId,
+		accountId,
+		{
+			mailboxId,
+			oldPath: before.fullPath,
+			newPath: renamed.fullPath,
+		},
+		before.hierarchyDelimiter,
+	);
+	return renamed;
 };
 
 /**

package/src/handlers/outbox.test.ts

@@ -143,6 +143,22 @@ const createInMemoryOutboxRepository = (): IOutboxMessageRepository => {
 const acceptingSqsClient = (): SQSClient =>
 	({ send: async () => ({}) }) as unknown as SQSClient;
 
+/** A queue that refuses every send until `accept()` is called. */
+const refusingSqsClient = (): { client: SQSClient; accept: () => void } => {
+	let accepting = false;
+	return {
+		client: {
+			send: async () => {
+				if (!accepting) throw new Error("SQS unavailable");
+				return {};
+			},
+		} as unknown as SQSClient,
+		accept: () => {
+			accepting = true;
+		},
+	};
+};
+
 const accountRepository = {
 	get: async () => ({
 		accountId: ACCOUNT_ID,
@@ -210,7 +226,7 @@ const createAttachmentRepository = (
 		},
 	}) as unknown as IOutboxAttachmentRepository;
 
-const installClient = (): void => {
+const installClient = (sqsClient: SQSClient = acceptingSqsClient()): void => {
 	const outboxMessage = createInMemoryOutboxRepository();
 	const storage = createMockStorageService();
 	attachmentRows = new Map<string, OutboxAttachmentItem>();
@@ -230,7 +246,7 @@ const installClient = (): void => {
 			outboxAttachmentService,
 			accountService: accountRepository,
 			sqsSmtpQueueUrl: "http://localhost:9324/queue/outbox-test",
-			sqsClient: acceptingSqsClient(),
+			sqsClient,
 		}),
 	} as unknown as RemitClient);
 };
@@ -259,6 +275,8 @@ const updateDraft =
 	OutboxDetailOperations.OutboxDetailOperations_updateOutboxMessage as Handler;
 const deleteDraft =
 	OutboxDetailOperations.OutboxDetailOperations_deleteOutboxMessage as Handler;
+const getMessage =
+	OutboxDetailOperations.OutboxDetailOperations_getOutboxMessage as Handler;
 
 type Outcome =
 	| { readonly ok: true; readonly body: Record<string, unknown> }
@@ -394,6 +412,90 @@ describe("an outbox entry that has left draft (#604)", () => {
 	});
 });
 
+describe("a send whose enqueue fails (#845.8)", () => {
+	const draftAgainstQueue = async (
+		queue: SQSClient,
+	): Promise<{ outboxMessageId: string; response: APIGatewayProxyResult }> => {
+		installClient(queue);
+		const draft = await createDraft(
+			requestContext({}),
+			authorizedEvent({
+				accountId: ACCOUNT_ID,
+				toAddresses: ["recipient@example.com"],
+				subject: "the one that got stuck",
+				textBody: "sending",
+			}),
+		);
+		const outboxMessageId = String(draft.outboxMessageId);
+		const response = await respond(() =>
+			sendMessage(
+				requestContext({ params: { outboxMessageId } }),
+				authorizedEvent(),
+			),
+		);
+		return { outboxMessageId, response };
+	};
+
+	const statusOf = async (outboxMessageId: string): Promise<unknown> => {
+		const response = await respond(() =>
+			getMessage(
+				requestContext({ params: { outboxMessageId } }),
+				authorizedEvent(),
+			),
+		);
+		assert.equal(response.statusCode, 200);
+		return (JSON.parse(response.body) as { status?: string }).status;
+	};
+
+	it("answers 500, never a success the send never had", async () => {
+		const { response } = await draftAgainstQueue(refusingSqsClient().client);
+
+		assert.equal(response.statusCode, 500);
+	});
+
+	it("leaves the row a draft, not stranded at queued", async () => {
+		const { outboxMessageId } = await draftAgainstQueue(
+			refusingSqsClient().client,
+		);
+
+		assert.equal(await statusOf(outboxMessageId), OutboxMessageStatus.draft);
+	});
+
+	it("still lets the user discard what could not be queued", async () => {
+		const { outboxMessageId } = await draftAgainstQueue(
+			refusingSqsClient().client,
+		);
+
+		const response = await respond(() =>
+			deleteDraft(
+				requestContext({ params: { outboxMessageId } }),
+				authorizedEvent(),
+			),
+		);
+
+		assert.equal(response.statusCode, 204);
+	});
+
+	it("sends once the queue comes back", async () => {
+		const queue = refusingSqsClient();
+		const { outboxMessageId } = await draftAgainstQueue(queue.client);
+		queue.accept();
+
+		const response = await respond(() =>
+			sendMessage(
+				requestContext({ params: { outboxMessageId } }),
+				authorizedEvent(),
+			),
+		);
+
+		assert.equal(response.statusCode, 200);
+		assert.equal(
+			(JSON.parse(response.body) as { status?: string }).status,
+			OutboxMessageStatus.queued,
+		);
+	});
+});
+
 describe("discarding a draft that carries files (#679)", () => {
 	it("takes the stored bytes with it, leaving nothing behind", async () => {
 		installClient();