@remit/backend 0.0.143 → 0.0.145

package/src/derive/enrichThreadRows.ts

@@ -1,234 +0,0 @@
-import type { ThreadMessageResponse } from "@remit/api-openapi-types";
-import type {
-	AddressItem,
-	LabelItem,
-	MessageItem,
-	MessageLabelItem,
-	ThreadMessageItem,
-} from "@remit/data-ports";
-import { deriveAddressId } from "@remit/data-ports/id";
-import {
-	MessageMutation,
-	MessageStatus,
-	MessageSyncStatus,
-	SenderTrust,
-	StarColor,
-} from "@remit/domain-enums";
-import { deriveAutoMoved } from "./autoMoved.js";
-import { deriveMuted } from "./deriveMuted.js";
-import { deriveSenderTrust } from "./senderTrust.js";
-
-/**
- * Subset of the ElectroDB client surface used for batch enrichment. Declared
- * structurally so unit tests can pass an in-memory fake without standing up
- * DynamoDB.
- */
-export interface EnrichClient {
-	message: {
-		get(messageIds: string[]): Promise<MessageItem[]>;
-	};
-	address: {
-		getAddress(
-			accountConfigId: string,
-			addressIds: string[],
-		): Promise<AddressItem[]>;
-	};
-	messageLabel: {
-		listByMessageIds(messageIds: string[]): Promise<MessageLabelItem[]>;
-	};
-	label: {
-		listByAccountConfig(accountConfigId: string): Promise<LabelItem[]>;
-	};
-}
-
-const toResponse = (item: ThreadMessageItem): ThreadMessageResponse => ({
-	threadMessageId: item.threadMessageId,
-	threadId: item.threadId,
-	messageId: item.messageId,
-	accountConfigId: item.accountConfigId,
-	mailboxId: item.mailboxId,
-	fromEmail: item.fromEmail,
-	fromName: item.fromName,
-	subject: item.subject,
-	sentDate: item.sentDate,
-	isRead: item.isRead,
-	hasAttachment: item.hasAttachment,
-	star: item.star ?? StarColor.None,
-	hasStars: item.hasStars,
-	isDeleted: item.isDeleted,
-	snippet: item.snippet,
-	category: item.category,
-	createdAt: item.createdAt,
-	updatedAt: item.updatedAt,
-	senderTrust: SenderTrust.Unknown,
-	muted: false,
-	status: MessageStatus.active,
-	syncStatus: MessageSyncStatus.pending,
-	abandonedMutation: MessageMutation.none,
-});
-
-/**
- * Plan the unique batch-fetch keys for a page of ThreadMessage rows.
- *
- * Splitting this out keeps the dedup logic testable without DynamoDB and
- * documents the contract: a page of N rows produces at most one BatchGet
- * for messages and one for addresses, no matter how many rows share the
- * same messageId / sender.
- *
- * `addressId` is derived deterministically from `(accountConfigId, fromEmail)`
- * via `deriveAddressId`, mirroring the write path in
- * `body-sync.ts`. Rows without a `fromEmail` (rare; sentinel/system rows)
- * contribute no addressId and fall back to `senderTrust: "unknown"`.
- */
-export interface BatchPlan {
-	messageIds: string[];
-	addressIds: string[];
-	addressIdByRow: Map<string, string>;
-}
-
-export const planBatchFetch = (rows: ThreadMessageItem[]): BatchPlan => {
-	const messageIds = new Set<string>();
-	const addressIds = new Set<string>();
-	const addressIdByRow = new Map<string, string>();
-
-	for (const row of rows) {
-		messageIds.add(row.messageId);
-
-		if (!row.fromEmail) continue;
-
-		const addressId = deriveAddressId(row.accountConfigId, row.fromEmail);
-		addressIds.add(addressId);
-		addressIdByRow.set(row.threadMessageId, addressId);
-	}
-
-	return {
-		messageIds: [...messageIds],
-		addressIds: [...addressIds],
-		addressIdByRow,
-	};
-};
-
-/**
- * Enrich a page of ThreadMessage rows with `senderTrust` and `muted` (both
- * derived from the From Address's flags map), `authenticity`, `autoMoved` and
- * `spamReport`, and the `status`/`syncStatus` pair an IMAP mutation leaves
- * behind together with the mutation an abandoned one names (all projected
- * straight from the Message row — no ThreadMessage
- * column of their own, see `deriveAutoMoved`). `toResponse` seeds that pair
- * with the ordinary inbound values, which the projection then overwrites; a
- * ThreadMessage row whose Message row is missing from the batch is broken in a
- * way this read path cannot report, and claiming a mutation it has no evidence
- * of would be worse.
- *
- * `category` is not enriched: it is denormalized onto the ThreadMessage row
- * (shared with `Message.category`'s write-once value, see body-sync.ts) and
- * carried straight through by `toResponse`, so the value a client renders is
- * the value the category filter matched.
- *
- * Two BatchGetItem calls per page, regardless of page size — see
- * `planBatchFetch` for the dedup contract.
- *
- * Missing rows fall back gracefully: `senderTrust` defaults to `"unknown"`,
- * `muted` defaults to `false`, and `authenticity` / `autoMoved` are omitted
- * whenever the Message row is absent or the move isn't a real, in-effect
- * auto-move.
- *
- * Not annotated `Promise<ThreadMessageResponse[]>`: `labels` is a new field on
- * it in this same PR, and that package publishes separately from this repo —
- * an explicit annotation here would contextually type the literal below
- * against the currently-*published* shape (which lacks `labels`) and fail
- * `check-consumer-typecheck`/`release:dry-run`. Callers assign the (wider,
- * inferred) result into an already-typed `ThreadMessageResponse[]` property,
- * which is a plain assignability check, not an excess-property one.
- */
-export const enrichThreadRows = async (
-	rows: ThreadMessageItem[],
-	client: EnrichClient,
-	accountConfigId: string,
-) => {
-	if (rows.length === 0) return [];
-
-	const plan = planBatchFetch(rows);
-
-	const [messages, addresses, messageLabels, labels] = await Promise.all([
-		plan.messageIds.length ? client.message.get(plan.messageIds) : [],
-		plan.addressIds.length
-			? client.address.getAddress(accountConfigId, plan.addressIds)
-			: [],
-		client.messageLabel.listByMessageIds(plan.messageIds),
-		client.label.listByAccountConfig(accountConfigId),
-	]);
-
-	const labelById = new Map(labels.map((label) => [label.labelId, label]));
-	const labelsByMessageId = new Map<
-		string,
-		{ labelId: string; name: string; color: LabelItem["color"] }[]
-	>();
-	for (const messageLabel of messageLabels) {
-		const label = labelById.get(messageLabel.labelId);
-		if (!label) continue;
-		const entry = {
-			labelId: label.labelId,
-			name: label.name,
-			color: label.color,
-		};
-		const existing = labelsByMessageId.get(messageLabel.messageId);
-		if (existing) {
-			existing.push(entry);
-		} else {
-			labelsByMessageId.set(messageLabel.messageId, [entry]);
-		}
-	}
-
-	const authenticityByMessageId = new Map(
-		messages.map((m) => [m.messageId, m.authenticity]),
-	);
-	const autoMovedByMessageId = new Map(
-		messages.map((m) => [m.messageId, deriveAutoMoved(m)]),
-	);
-	const spamReportByMessageId = new Map(
-		messages.map((m) => [m.messageId, m.spamReport]),
-	);
-	const settlementByMessageId = new Map(
-		messages.map((m) => [
-			m.messageId,
-			{
-				status: m.status,
-				syncStatus: m.syncStatus,
-				abandonedMutation: m.abandonedMutation,
-			},
-		]),
-	);
-	const trustByAddressId = new Map(
-		addresses.map((a) => [a.addressId, deriveSenderTrust(a.flags)]),
-	);
-	const mutedByAddressId = new Map(
-		addresses.map((a) => [a.addressId, deriveMuted(a.flags)]),
-	);
-
-	return rows.map((row) => {
-		const base = toResponse(row);
-		const authenticity = authenticityByMessageId.get(row.messageId);
-		const autoMoved = autoMovedByMessageId.get(row.messageId);
-		const spamReport = spamReportByMessageId.get(row.messageId);
-		const addressId = plan.addressIdByRow.get(row.threadMessageId);
-		const senderTrust = addressId
-			? (trustByAddressId.get(addressId) ?? SenderTrust.Unknown)
-			: SenderTrust.Unknown;
-		const muted = addressId
-			? (mutedByAddressId.get(addressId) ?? false)
-			: false;
-		const labels = labelsByMessageId.get(row.messageId);
-		const settlement = settlementByMessageId.get(row.messageId);
-		return {
-			...base,
-			...(settlement ?? {}),
-			...(authenticity !== undefined ? { authenticity } : {}),
-			...(autoMoved !== undefined ? { autoMoved } : {}),
-			...(labels !== undefined ? { labels } : {}),
-			...(spamReport !== undefined ? { spamReport } : {}),
-			senderTrust,
-			muted,
-		};
-	});
-};

package/src/derive/filterThreadCriteria.test.ts

@@ -1,126 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { ThreadMessageResponse } from "@remit/api-openapi-types";
-import {
-	MessageCategory,
-	MessageMutation,
-	MessageStatus,
-	MessageSyncStatus,
-	SenderTrust,
-	StarColor,
-} from "@remit/domain-enums";
-import {
-	filterByOffRowCriteria,
-	hasOffRowCriteria,
-} from "./filterThreadCriteria.js";
-
-const row = (
-	overrides: Partial<ThreadMessageResponse>,
-): ThreadMessageResponse => ({
-	threadMessageId: "tm",
-	threadId: "t",
-	messageId: "m",
-	accountConfigId: "acc",
-	mailboxId: "mb",
-	subject: "s",
-	fromEmail: "a@example.com",
-	fromName: "A",
-	sentDate: 0,
-	isRead: false,
-	hasAttachment: false,
-	hasStars: false,
-	star: StarColor.None,
-	isDeleted: false,
-	snippet: "",
-	category: MessageCategory.uncategorized,
-	createdAt: 0,
-	updatedAt: 0,
-	senderTrust: SenderTrust.Unknown,
-	muted: false,
-	status: MessageStatus.active,
-	syncStatus: MessageSyncStatus.pending,
-	abandonedMutation: MessageMutation.none,
-	...overrides,
-});
-
-describe("hasOffRowCriteria", () => {
-	it("is false for an empty criteria object", () => {
-		assert.equal(hasOffRowCriteria({}), false);
-	});
-
-	it("is false for empty arrays", () => {
-		assert.equal(hasOffRowCriteria({ senderTrust: [] }), false);
-	});
-
-	it("is true when any criterion is set", () => {
-		assert.equal(hasOffRowCriteria({ senderTrust: [SenderTrust.Vip] }), true);
-		assert.equal(hasOffRowCriteria({ dkimMismatch: false }), true);
-	});
-});
-
-describe("filterByOffRowCriteria", () => {
-	it("returns rows untouched when no criteria are active", () => {
-		const rows = [row({}), row({})];
-		assert.equal(filterByOffRowCriteria(rows, {}).length, 2);
-	});
-
-	it("filters by senderTrust any-of", () => {
-		const rows = [
-			row({ senderTrust: SenderTrust.Vip }),
-			row({ senderTrust: SenderTrust.Wellknown }),
-			row({ senderTrust: SenderTrust.Unknown }),
-		];
-		const result = filterByOffRowCriteria(rows, {
-			senderTrust: [SenderTrust.Vip, SenderTrust.Wellknown],
-		});
-		assert.equal(result.length, 2);
-		assert.ok(result.every((r) => r.senderTrust !== SenderTrust.Unknown));
-	});
-
-	it("leaves category alone — it is a SQL predicate, not an off-row criterion", () => {
-		const rows = [
-			row({ category: MessageCategory.newsletter }),
-			row({ category: MessageCategory.personal }),
-		];
-		assert.equal(filterByOffRowCriteria(rows, {}).length, 2);
-	});
-
-	it("filters by dkimMismatch and never matches rows lacking an authenticity signal", () => {
-		const rows = [
-			row({ authenticity: { fromDomain: "x", dkimMismatch: false } }),
-			row({ authenticity: { fromDomain: "y", dkimMismatch: true } }),
-			row({ authenticity: undefined }),
-		];
-		const aligned = filterByOffRowCriteria(rows, { dkimMismatch: false });
-		assert.equal(aligned.length, 1);
-		assert.equal(aligned[0].authenticity?.dkimMismatch, false);
-
-		const mismatched = filterByOffRowCriteria(rows, { dkimMismatch: true });
-		assert.equal(mismatched.length, 1);
-		assert.equal(mismatched[0].authenticity?.dkimMismatch, true);
-	});
-
-	it("ANDs criteria together (Rescue shape: trust set + dkim aligned)", () => {
-		const rows = [
-			row({
-				senderTrust: SenderTrust.Vip,
-				authenticity: { fromDomain: "x", dkimMismatch: false },
-			}),
-			row({
-				senderTrust: SenderTrust.Vip,
-				authenticity: { fromDomain: "y", dkimMismatch: true },
-			}),
-			row({
-				senderTrust: SenderTrust.Unknown,
-				authenticity: { fromDomain: "z", dkimMismatch: false },
-			}),
-		];
-		const result = filterByOffRowCriteria(rows, {
-			senderTrust: [SenderTrust.Vip, SenderTrust.Wellknown],
-			dkimMismatch: false,
-		});
-		assert.equal(result.length, 1);
-		assert.equal(result[0].senderTrust, SenderTrust.Vip);
-		assert.equal(result[0].authenticity?.dkimMismatch, false);
-	});
-});

package/src/derive/filterThreadCriteria.ts

@@ -1,51 +0,0 @@
-import type {
-	SenderTrust,
-	ThreadMessageResponse,
-} from "@remit/api-openapi-types";
-
-/**
- * Off-row search criteria — fields that live on the underlying Message/Address,
- * not on the ThreadMessage row. They are resolved by enriching the windowed
- * rows (see enrichThreadRows) and filtering in app code, because no index or
- * FilterExpression can serve them.
- *
- * `senderTrust` derives from AddressItem.flags and `dkimMismatch` from
- * MessageItem.authenticity. `category` is not one of these: it is denormalized
- * onto the ThreadMessage row and filtered in SQL, inside the window.
- */
-export interface OffRowCriteria {
-	senderTrust?: SenderTrust[];
-	dkimMismatch?: boolean;
-}
-
-export const hasOffRowCriteria = (criteria: OffRowCriteria): boolean =>
-	Boolean(criteria.senderTrust?.length) || criteria.dkimMismatch !== undefined;
-
-/**
- * Filter enriched rows by the off-row criteria. Each active criterion is an
- * any-of set (AND across criteria, OR within a set). A row with no
- * `authenticity` signal never matches a `dkimMismatch` filter (absence means no
- * signal, not a verdict).
- */
-export const filterByOffRowCriteria = (
-	rows: ThreadMessageResponse[],
-	criteria: OffRowCriteria,
-): ThreadMessageResponse[] => {
-	if (!hasOffRowCriteria(criteria)) return rows;
-
-	const trustSet = criteria.senderTrust?.length
-		? new Set(criteria.senderTrust)
-		: undefined;
-	const { dkimMismatch } = criteria;
-
-	return rows.filter((row) => {
-		if (trustSet && !trustSet.has(row.senderTrust)) return false;
-		if (
-			dkimMismatch !== undefined &&
-			row.authenticity?.dkimMismatch !== dkimMismatch
-		) {
-			return false;
-		}
-		return true;
-	});
-};

package/src/derive/senderTrust.test.ts

@@ -1,67 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { AddressFlags } from "@remit/api-openapi-types";
-import { deriveSenderTrust } from "./senderTrust.js";
-
-// AddressFlagBase requires setAt; deriveSenderTrust only reads `value`, so the
-// timestamp value is irrelevant to these assertions.
-const SET_AT = 1_700_000_000_000;
-
-describe("deriveSenderTrust", () => {
-	it("returns 'unknown' when flags is undefined", () => {
-		assert.equal(deriveSenderTrust(undefined), "unknown");
-	});
-
-	it("returns 'unknown' for an empty flags object", () => {
-		assert.equal(deriveSenderTrust({}), "unknown");
-	});
-
-	it("returns 'unknown' when wellknown.value is false", () => {
-		const flags: AddressFlags = { wellknown: { value: false, setAt: SET_AT } };
-		assert.equal(deriveSenderTrust(flags), "unknown");
-	});
-
-	it("returns 'wellknown' when wellknown.value is true", () => {
-		const flags: AddressFlags = { wellknown: { value: true, setAt: SET_AT } };
-		assert.equal(deriveSenderTrust(flags), "wellknown");
-	});
-
-	it("returns 'vip' when vip.value is true", () => {
-		const flags: AddressFlags = { vip: { value: true, setAt: SET_AT } };
-		assert.equal(deriveSenderTrust(flags), "vip");
-	});
-
-	it("returns 'unknown' when vip.value is false", () => {
-		const flags: AddressFlags = { vip: { value: false, setAt: SET_AT } };
-		assert.equal(deriveSenderTrust(flags), "unknown");
-	});
-
-	it("vip wins over wellknown when both are true", () => {
-		const flags: AddressFlags = {
-			vip: { value: true, setAt: SET_AT },
-			wellknown: { value: true, setAt: SET_AT },
-		};
-		assert.equal(deriveSenderTrust(flags), "vip");
-	});
-
-	it("falls back to wellknown when vip is false but wellknown is true", () => {
-		const flags: AddressFlags = {
-			vip: { value: false, setAt: SET_AT },
-			wellknown: { value: true, setAt: SET_AT },
-		};
-		assert.equal(deriveSenderTrust(flags), "wellknown");
-	});
-
-	it("ignores trusted flag (orthogonal axis)", () => {
-		const flags: AddressFlags = { trusted: { value: true, setAt: SET_AT } };
-		assert.equal(deriveSenderTrust(flags), "unknown");
-	});
-
-	it("ignores trusted even when wellknown is also set", () => {
-		const flags: AddressFlags = {
-			trusted: { value: true, setAt: SET_AT },
-			wellknown: { value: true, setAt: SET_AT },
-		};
-		assert.equal(deriveSenderTrust(flags), "wellknown");
-	});
-});

package/src/error.test.ts

@@ -1,201 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import type { ApiError, FolderRoleConflict } from "@remit/api-openapi-types";
-import {
-	BadRequestError,
-	ClientError,
-	ConflictError,
-	FolderRoleUnresolvedError,
-	ForbiddenError,
-	NotFoundError,
-	UnhandledError,
-	UnrecoverableBodyError,
-} from "@remit/data-ports/errors";
-import { NO_TRASH_FOLDER_REASON } from "@remit/data-ports/folder-role";
-import { CanonicalMailboxRole } from "@remit/domain-enums";
-import { NoTrashMailboxError } from "@remit/mailbox-service";
-import { handleError } from "./error.js";
-
-const parseBody = (body: string): Record<string, unknown> =>
-	JSON.parse(body) as Record<string, unknown>;
-
-// One shape for every error the API answers with (issue #371): flat, always a
-// `code`, always a `message`. A status class that reaches a client without a
-// code leaves it branching on prose.
-describe("the wire shape of a refusal, per status class", () => {
-	const cases: ReadonlyArray<[string, Error, number, string]> = [
-		[
-			"400",
-			new BadRequestError("confirmEmail is required"),
-			400,
-			"invalid_request",
-		],
-		["401", new ClientError("Session expired"), 401, "unauthorized"],
-		["403", new ForbiddenError("Not your account"), 403, "forbidden"],
-		["404", new NotFoundError("Mailbox not found: mb-1"), 404, "not_found"],
-		[
-			"409",
-			new ConflictError("An update is already in progress."),
-			409,
-			"conflict",
-		],
-		[
-			"422",
-			new UnrecoverableBodyError("This message's body could not be read."),
-			422,
-			"unprocessable_entity",
-		],
-	];
-
-	for (const [name, error, statusCode, code] of cases) {
-		it(`answers ${name} with a flat code and message`, async () => {
-			const response = await handleError(error);
-
-			assert.equal(response.statusCode, statusCode);
-			assert.deepEqual(parseBody(response.body), {
-				code,
-				message: error.message,
-			});
-		});
-	}
-
-	// A 5xx is the one class whose message is not the thrower's. Those sentences
-	// are written for a log line and name hosts, queries and ids; the correlation
-	// id on the response is how the real one is found.
-	it("answers 500 with one code and one sentence, never the thrower's", async () => {
-		const response = await handleError(
-			new UnhandledError(
-				"pg://reader@db-3.internal:5432 timed out on SELECT * FROM message",
-			),
-		);
-
-		assert.equal(response.statusCode, 500);
-		assert.deepEqual(parseBody(response.body), {
-			code: "internal_error",
-			message: "Internal server error",
-		});
-	});
-
-	it("types every one of those bodies as the declared ApiError", async () => {
-		const response = await handleError(new NotFoundError("Gone"));
-		const body: ApiError = JSON.parse(response.body);
-
-		assert.equal(body.code, "not_found");
-		assert.equal(body.message, "Gone");
-	});
-});
-
-describe("handleError coded refusals", () => {
-	it("puts the code and every detail of a folder-role 409 on the wire", async () => {
-		const response = await handleError(
-			new FolderRoleUnresolvedError(
-				"The folder you chose for Trash is gone.",
-				CanonicalMailboxRole.Trash,
-				"stale",
-				"account-7",
-			),
-		);
-
-		assert.equal(response.statusCode, 409);
-		assert.deepEqual(parseBody(response.body), {
-			message: "The folder you chose for Trash is gone.",
-			code: "folder_role_unresolved",
-			details: { role: "Trash", reason: "stale", accountId: "account-7" },
-		});
-	});
-
-	it("carries NoTrashMailboxError as the Trash role with reason none", async () => {
-		const response = await handleError(new NoTrashMailboxError("account-7"));
-
-		assert.equal(response.statusCode, 409);
-		assert.deepEqual(parseBody(response.body), {
-			message: NO_TRASH_FOLDER_REASON,
-			code: "folder_role_unresolved",
-			details: { role: "Trash", reason: "none", accountId: "account-7" },
-		});
-	});
-
-	it("keeps an unhandled 500 to a code and a message — no stack, no cause, no details", async () => {
-		const response = await handleError(
-			new UnhandledError("Something went wrong", new Error("connection reset")),
-		);
-
-		assert.equal(response.statusCode, 500);
-		assert.deepEqual(parseBody(response.body), {
-			code: "internal_error",
-			message: "Internal server error",
-		});
-	});
-
-	it("replaces a code a 5xx should never have carried, and drops its details", async () => {
-		const error = new UnhandledError("Something went wrong");
-		error.publicApiError = {
-			code: "folder_role_unresolved",
-			details: { role: "Trash", reason: "none", accountId: "account-7" },
-		};
-
-		const response = await handleError(error);
-
-		assert.equal(response.statusCode, 500);
-		assert.deepEqual(parseBody(response.body), {
-			code: "internal_error",
-			message: "Internal server error",
-		});
-	});
-
-	it("keeps an infrastructure failure to the generic message and code", async () => {
-		const error = Object.assign(
-			new Error("aws-error: ProvisionedThroughputExceeded on remit-main"),
-			{ name: "ElectroError" },
-		);
-
-		const response = await handleError(error);
-
-		assert.equal(response.statusCode, 500);
-		assert.deepEqual(parseBody(response.body), {
-			code: "internal_error",
-			message: "Database temporarily unavailable",
-		});
-	});
-
-	it("answers a malformed query as a 400 with the query's own message", async () => {
-		const error = Object.assign(new Error("Invalid attribute: sentDate"), {
-			name: "ElectroError",
-		});
-
-		const response = await handleError(error);
-
-		assert.equal(response.statusCode, 400);
-		assert.deepEqual(parseBody(response.body), {
-			code: "invalid_request",
-			message: "Invalid attribute: sentDate",
-		});
-	});
-
-	// The contract and the emitter cannot drift apart: this asserts the response
-	// `handleError` actually builds against the generated model. Nesting the body
-	// under `error` again would leave `code` off `keyof FolderRoleConflict` and
-	// fail to compile here, long before a client reads a 409 it cannot parse.
-	it("matches the generated FolderRoleConflict model field for field", async () => {
-		const response = await handleError(
-			new FolderRoleUnresolvedError(
-				"Nobody has confirmed a Trash folder.",
-				CanonicalMailboxRole.Trash,
-				"unconfirmed",
-				"account-7",
-			),
-		);
-		const body: Omit<FolderRoleConflict, "statusCode"> = JSON.parse(
-			response.body,
-		);
-		const declaredFields: ReadonlyArray<keyof typeof body> = [
-			"code",
-			"details",
-			"message",
-		];
-
-		assert.equal(response.statusCode, 409);
-		assert.deepEqual(Object.keys(body).sort(), [...declaredFields].sort());
-		assert.equal(body.code, "folder_role_unresolved");
-	});
-});