@remit/mailbox-service 0.0.70 → 0.0.72

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.70",
+  "version": "0.0.72",
   "type": "module",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/imapflow-connection.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert";
 import { describe, it } from "node:test";
 import {
+	convertSearchCriteria,
 	ImapFlowConnection,
 	toInternalDate,
 	toIsoDateString,
@@ -112,6 +113,96 @@ const fakeMailbox = (path: string, exists: number) => ({
 	readOnly: true,
 });
 
+describe("convertSearchCriteria — a criterion never silently widens to ALL (#912)", () => {
+	it("compiles a Message-ID header criterion into a header query", () => {
+		assert.deepStrictEqual(
+			convertSearchCriteria([["HEADER", "Message-ID", "<abc@example.com>"]]),
+			{ header: { "message-id": "<abc@example.com>" } },
+		);
+	});
+
+	it("carries a Message-ID holding a quote and a CRLF as a value, not as syntax", () => {
+		const hostile = '<a"b@example.com>\r\nUID 1';
+
+		assert.deepStrictEqual(
+			convertSearchCriteria([["HEADER", "Message-ID", hostile]]),
+			{ header: { "message-id": hostile } },
+		);
+	});
+
+	it("keeps a __proto__ header name as an own query term instead of losing it to the prototype setter", () => {
+		const query = convertSearchCriteria([["HEADER", "__proto__", "x"]]);
+		const header = query.header;
+
+		assert.ok(typeof header === "object" && header !== null);
+		assert.deepStrictEqual(Object.getOwnPropertyNames(header), ["__proto__"]);
+		assert.strictEqual(
+			Object.getOwnPropertyDescriptor(header, "__proto__")?.value,
+			"x",
+		);
+		assert.notDeepStrictEqual(query, {});
+	});
+
+	it("throws on an empty criteria list rather than compiling to {}", () => {
+		assert.throws(
+			() => convertSearchCriteria([]),
+			/Empty IMAP search criteria list/,
+		);
+	});
+
+	it("merges several header criteria into one header query", () => {
+		assert.deepStrictEqual(
+			convertSearchCriteria([
+				["HEADER", "Message-ID", "<a@example.com>"],
+				["HEADER", "X-Remit-Trace", "abc"],
+			]),
+			{ header: { "message-id": "<a@example.com>", "x-remit-trace": "abc" } },
+		);
+	});
+
+	it("still compiles the flag and value criteria every caller uses", () => {
+		assert.deepStrictEqual(convertSearchCriteria(["ALL"]), {});
+		assert.deepStrictEqual(convertSearchCriteria(["DELETED"]), {
+			deleted: true,
+		});
+		assert.deepStrictEqual(convertSearchCriteria([["UID", "42"]]), {
+			uid: "42",
+		});
+	});
+
+	it("throws on an unrecognised string criterion instead of compiling to {}", () => {
+		assert.throws(
+			() => convertSearchCriteria(['HEADER Message-ID "<abc@example.com>"']),
+			/Unsupported IMAP search criterion/,
+		);
+	});
+
+	it("throws on an unrecognised keyed criterion", () => {
+		assert.throws(
+			() => convertSearchCriteria([["BODY", "invoice"]]),
+			/Unsupported IMAP search criterion/,
+		);
+	});
+
+	it("throws on a keyed criterion carrying the wrong number of values", () => {
+		assert.throws(
+			() => convertSearchCriteria([["UID"]]),
+			/Unsupported IMAP search criterion/,
+		);
+		assert.throws(
+			() => convertSearchCriteria([["HEADER", "Message-ID"]]),
+			/Unsupported IMAP search criterion/,
+		);
+	});
+
+	it("throws on a criterion that is neither a string nor an array", () => {
+		assert.throws(
+			() => convertSearchCriteria([{ header: "Message-ID" }]),
+			/Unsupported IMAP search criterion/,
+		);
+	});
+});
+
 describe("ImapFlowConnection.search — the probe every stale-row reconcile rests on (#102)", () => {
 	const buildSearchConnection = (
 		result: unknown,
@@ -140,6 +231,21 @@ describe("ImapFlowConnection.search — the probe every stale-row reconcile rest
 		]);
 	});
 
+	it("hands imapflow a header query for a Message-ID probe, not an empty object", async () => {
+		const calls: Array<{ query: unknown; options: unknown }> = [];
+		const connection = buildSearchConnection([], calls);
+		await connection.openBox("Archive", true);
+
+		await connection.search([["HEADER", "Message-ID", "<abc@example.com>"]]);
+
+		assert.deepStrictEqual(calls, [
+			{
+				query: { header: { "message-id": "<abc@example.com>" } },
+				options: { uid: true },
+			},
+		]);
+	});
+
 	it("answers an empty array when the server matched nothing", async () => {
 		const connection = buildSearchConnection([]);
 		await connection.openBox("INBOX", true);

package/src/imapflow-connection.ts

@@ -68,6 +68,103 @@ export const toInternalDate = (value: unknown): Date | null => {
 	return new Date();
 };
 
+const FLAG_CRITERIA: Record<string, Record<string, boolean>> = {
+	ALL: {},
+	SEEN: { seen: true },
+	UNSEEN: { seen: false },
+	FLAGGED: { flagged: true },
+	UNFLAGGED: { flagged: false },
+	DELETED: { deleted: true },
+	UNDELETED: { deleted: false },
+	ANSWERED: { answered: true },
+	UNANSWERED: { answered: false },
+	DRAFT: { draft: true },
+	UNDRAFT: { draft: false },
+};
+
+const VALUE_CRITERIA: Record<string, string> = {
+	UID: "uid",
+	FROM: "from",
+	TO: "to",
+	SUBJECT: "subject",
+	SINCE: "since",
+	BEFORE: "before",
+};
+
+const unsupported = (criterion: unknown): Error =>
+	new Error(
+		`Unsupported IMAP search criterion ${JSON.stringify(criterion)} — dropping it would widen the query to SEARCH ALL`,
+	);
+
+const applyValueCriterion = (
+	result: Record<string, unknown>,
+	header: Map<string, string>,
+	criterion: unknown[],
+): void => {
+	const [key, ...values] = criterion;
+	if (typeof key !== "string") throw unsupported(criterion);
+
+	if (key.toUpperCase() === "HEADER") {
+		const [name, value] = values;
+		if (values.length !== 2 || typeof name !== "string") {
+			throw unsupported(criterion);
+		}
+		if (typeof value !== "string" && value !== true) {
+			throw unsupported(criterion);
+		}
+		header.set(name.toLowerCase(), value === true ? "" : value);
+		return;
+	}
+
+	const field = VALUE_CRITERIA[key.toUpperCase()];
+	if (field === undefined || values.length !== 1) throw unsupported(criterion);
+	result[field] = values[0];
+};
+
+/**
+ * Compile node-imap style search criteria into an ImapFlow search object.
+ *
+ * A criterion this does not understand throws, and so does an empty criteria
+ * list. imapflow reads an empty object as `SEARCH ALL`
+ * (`imapflow/lib/commands/search.js`), so quietly skipping one turns a narrow
+ * probe into "every message in the mailbox" — the reconcile and move paths then
+ * act on a stranger's UID (#912). Header names accumulate in a Map so that a
+ * name like `__proto__` lands as a query term rather than hitting the
+ * prototype setter and vanishing.
+ *
+ * Values travel as structured tokens, never interpolated into a criterion
+ * string, so a quote or a CRLF in a header value cannot alter the query.
+ */
+export const convertSearchCriteria = (
+	criteria: unknown[],
+): Record<string, unknown> => {
+	if (criteria.length === 0) {
+		throw new Error(
+			"Empty IMAP search criteria list — it would compile to SEARCH ALL",
+		);
+	}
+
+	const result: Record<string, unknown> = {};
+	const header = new Map<string, string>();
+
+	for (const criterion of criteria) {
+		if (typeof criterion === "string") {
+			const flags = FLAG_CRITERIA[criterion.toUpperCase()];
+			if (flags === undefined) throw unsupported(criterion);
+			Object.assign(result, flags);
+			continue;
+		}
+		if (Array.isArray(criterion)) {
+			applyValueCriterion(result, header, criterion);
+			continue;
+		}
+		throw unsupported(criterion);
+	}
+
+	if (header.size > 0) result.header = Object.fromEntries(header);
+	return result;
+};
+
 /**
  * ImapFlow-based IMAP connection
  *
@@ -414,8 +511,7 @@ export class ImapFlowConnection {
 			throw new Error("No mailbox selected");
 		}
 
-		// Convert node-imap style criteria to ImapFlow search object
-		const searchQuery = this.convertSearchCriteria(criteria);
+		const searchQuery = convertSearchCriteria(criteria);
 
 		const result = await this.client?.search(searchQuery, { uid: true });
 		if (!Array.isArray(result)) {
@@ -424,83 +520,6 @@ export class ImapFlowConnection {
 		return result;
 	};
 
-	/**
-	 * Convert node-imap style search criteria to ImapFlow format
-	 */
-	private convertSearchCriteria = (
-		criteria: unknown[],
-	): Record<string, unknown> => {
-		const result: Record<string, unknown> = {};
-
-		for (const criterion of criteria) {
-			if (typeof criterion === "string") {
-				// Simple flags like "ALL", "UNSEEN", etc.
-				switch (criterion.toUpperCase()) {
-					case "ALL":
-						// ALL is default, no filter needed
-						break;
-					case "UNSEEN":
-						result.seen = false;
-						break;
-					case "SEEN":
-						result.seen = true;
-						break;
-					case "FLAGGED":
-						result.flagged = true;
-						break;
-					case "UNFLAGGED":
-						result.flagged = false;
-						break;
-					case "DELETED":
-						result.deleted = true;
-						break;
-					case "UNDELETED":
-						result.deleted = false;
-						break;
-					case "ANSWERED":
-						result.answered = true;
-						break;
-					case "UNANSWERED":
-						result.answered = false;
-						break;
-					case "DRAFT":
-						result.draft = true;
-						break;
-					case "UNDRAFT":
-						result.draft = false;
-						break;
-				}
-			} else if (Array.isArray(criterion)) {
-				// Criteria with values like ["UID", "1:*"]
-				const [key, value] = criterion;
-				if (typeof key === "string") {
-					switch (key.toUpperCase()) {
-						case "UID":
-							result.uid = value;
-							break;
-						case "FROM":
-							result.from = value;
-							break;
-						case "TO":
-							result.to = value;
-							break;
-						case "SUBJECT":
-							result.subject = value;
-							break;
-						case "SINCE":
-							result.since = value;
-							break;
-						case "BEFORE":
-							result.before = value;
-							break;
-					}
-				}
-			}
-		}
-
-		return result;
-	};
-
 	/**
 	 * Fetch messages by UID
 	 *

package/src/outbox-queue-settled-row.test.ts

@@ -0,0 +1,128 @@
+/**
+ * A row the SMTP worker settled has to be a row the user can still act on.
+ *
+ * `sending` is not: `send` takes draft, failed and blocked, and `deleteDraft`
+ * those three plus `unfiled`, so a send that never reached the server left a
+ * row that 409s on both buttons forever (#951). The worker now settles that
+ * row instead of dead-lettering it, and these are the two moves the settled
+ * status has to accept for the settle to be worth anything.
+ */
+
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type {
+	IAccountRepository,
+	IOutboxMessageRepository,
+	OutboxMessageItem,
+} from "@remit/data-ports";
+import { OutboxMessageStatus } from "@remit/domain-enums";
+import type { OutboxAttachmentService } from "./outbox-attachment.js";
+import { OutboxQueueService } from "./outbox-queue.js";
+
+const ACCOUNT_CONFIG_ID = "cfg-1";
+const ACCOUNT_ID = "acc-1";
+const OUTBOX_MESSAGE_ID = "ob-1";
+
+const row = (status: OutboxMessageItem["status"]): OutboxMessageItem =>
+	({
+		outboxMessageId: OUTBOX_MESSAGE_ID,
+		accountId: ACCOUNT_ID,
+		accountConfigId: ACCOUNT_CONFIG_ID,
+		fromAddress: "me@example.com",
+		toAddresses: ["them@example.com"],
+		ccAddresses: [],
+		bccAddresses: [],
+		references: [],
+		messageIdValue: "<m1@example.com>",
+		lastError: "SMTP connection failed: ECONNREFUSED",
+		status,
+		createdAt: 0,
+		updatedAt: 0,
+	}) as unknown as OutboxMessageItem;
+
+interface Harness {
+	service: OutboxQueueService;
+	enqueued: string[];
+	statusWrites: string[];
+	deleted: string[];
+	discarded: string[];
+}
+
+const createHarness = (stored: OutboxMessageItem): Harness => {
+	const harness: Harness = {
+		service: undefined as unknown as OutboxQueueService,
+		enqueued: [],
+		statusWrites: [],
+		deleted: [],
+		discarded: [],
+	};
+
+	const outboxMessageService = {
+		get: async () => stored,
+		updateStatus: async (
+			_configId: string,
+			_id: string,
+			status: OutboxMessageItem["status"],
+		) => {
+			harness.statusWrites.push(status);
+			return { ...stored, status };
+		},
+		delete: async (_configId: string, id: string) => {
+			harness.deleted.push(id);
+		},
+	} as unknown as IOutboxMessageRepository;
+
+	harness.service = new OutboxQueueService({
+		outboxMessageService,
+		outboxAttachmentService: {
+			discardAll: async (_configId: string, _accountId: string, id: string) => {
+				harness.discarded.push(id);
+			},
+		} as unknown as OutboxAttachmentService,
+		accountService: {} as unknown as IAccountRepository,
+		sqsSmtpQueueUrl: "http://localhost/queue",
+		sqsClient: {
+			send: async (command: { input: { MessageBody: string } }) => {
+				harness.enqueued.push(command.input.MessageBody);
+				return {};
+			},
+		} as never,
+	});
+
+	return harness;
+};
+
+describe("a row the worker settled at `failed`", () => {
+	it("is sendable again — Retry is the whole point of settling there", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.failed));
+
+		await harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+
+		assert.deepEqual(harness.statusWrites, [OutboxMessageStatus.queued]);
+		assert.equal(harness.enqueued.length, 1);
+	});
+
+	it("is discardable — the other way out of the Outbox", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.failed));
+
+		await harness.service.deleteDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+
+		assert.deepEqual(harness.deleted, [OUTBOX_MESSAGE_ID]);
+		assert.deepEqual(harness.discarded, [OUTBOX_MESSAGE_ID]);
+	});
+});
+
+describe("a row the worker settled at `unfiled`", () => {
+	it("is discardable but never sendable — the server may already hold it", async () => {
+		const harness = createHarness(row(OutboxMessageStatus.unfiled));
+
+		await assert.rejects(
+			() => harness.service.send(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID),
+			/cannot be sent again/,
+		);
+		assert.deepEqual(harness.enqueued, [], "nothing reached the SMTP queue");
+
+		await harness.service.deleteDraft(ACCOUNT_CONFIG_ID, OUTBOX_MESSAGE_ID);
+		assert.deepEqual(harness.deleted, [OUTBOX_MESSAGE_ID]);
+	});
+});