@remit/mailbox-service 0.0.69 → 0.0.71

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/mailbox-service",
-  "version": "0.0.69",
+  "version": "0.0.71",
   "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.ts

@@ -231,7 +231,21 @@ export class OutboxQueueService {
 			OutboxMessageStatus.queued,
 		);
 
-		await this.enqueueSend(existing.accountId, outboxMessageId);
+		// `queued` is a dead end for a row the queue never accepted: `send` takes
+		// draft, failed and blocked, `deleteDraft` those three plus unfiled, so a
+		// row parked at `queued` by a failed enqueue is neither sendable nor
+		// discardable (#845.8). Put it back where it came from and let the enqueue
+		// failure surface — the row stays reachable, the caller still hears no.
+		await this.enqueueSend(existing.accountId, outboxMessageId).catch(
+			async (error: unknown) => {
+				await this.outboxMessageService.updateStatus(
+					accountConfigId,
+					outboxMessageId,
+					existing.status,
+				);
+				throw error;
+			},
+		);
 
 		this.log.info(
 			{ outboxMessageId, accountId: existing.accountId },