@remit/smtp-worker 1.0.7 → 1.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/smtp-worker",
-	"version": "1.0.7",
+	"version": "1.0.8",
 	"type": "module",
 	"main": "dist/index.js",
 	"exports": {

package/src/handlers/send-message.test.ts

@@ -226,10 +226,20 @@ const attach = async (
 	});
 };
 
-const refusingSocket =
-	(code: string): SendMessageContext["getSocket"] =>
+const closedPort = (): Promise<number> =>
+	new Promise((resolve) => {
+		const server = net.createServer();
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			const port = typeof address === "object" && address ? address.port : 0;
+			server.close(() => resolve(port));
+		});
+	});
+
+const socketTo =
+	(port: number): SendMessageContext["getSocket"] =>
 	(_request, callback) => {
-		callback(Object.assign(new Error(`connect ${code}`), { code }), false);
+		callback(null, { connection: net.connect(port, "127.0.0.1") });
 	};
 
 const seedAddress = async (w: World, email: string): Promise<string> => {
@@ -675,7 +685,7 @@ describe("handleSendMessage retry-budget exhaustion (issue #951)", () => {
 
 		await handleSendMessage(
 			a.event,
-			{ ...w.ctx, getSocket: refusingSocket("ECONNREFUSED"), maxAttempts: 1 },
+			{ ...w.ctx, getSocket: socketTo(await closedPort()), maxAttempts: 1 },
 			1,
 		);
 
@@ -685,24 +695,39 @@ describe("handleSendMessage retry-budget exhaustion (issue #951)", () => {
 		assert.deepEqual(w.failures, ["network"]);
 	});
 
-	for (const code of ["ECONNRESET", "ETIMEDOUT"]) {
-		it(`settles an exhausted ${code} at \`unfiled\` — the server may hold the message`, async () => {
-			// Both classify as `network` and both can land after DATA, so a
-			// `failed` row here would offer a Retry that delivers a second copy.
-			const a = await arrange(w);
+	it("retries a connection the server drops before DATA, then settles it `failed`", async () => {
+		w.close();
+		w = await openWorld({ dropBeforeGreeting: true });
+		const a = await arrange(w);
 
-			await handleSendMessage(
-				a.event,
-				{ ...w.ctx, getSocket: refusingSocket(code) },
-				MAX_ATTEMPTS,
-			);
+		await assert.rejects(
+			() => handleSendMessage(a.event, w.ctx, MAX_ATTEMPTS - 1),
+			SmtpConnectionError,
+		);
+		await handleSendMessage(a.event, w.ctx, MAX_ATTEMPTS);
 
-			const row = await outboxRow(w, a);
-			assert.equal(row.status, OutboxMessageStatus.unfiled);
-			assert.match(String(row.lastError), /may already have been delivered/);
-			assert.match(String(row.lastError), new RegExp(code));
-		});
-	}
+		const row = await outboxRow(w, a);
+		assert.equal(row.status, OutboxMessageStatus.failed);
+		assert.equal(w.smtp.received.length, 0);
+		assert.deepEqual(w.failures, ["network"]);
+	});
+
+	it("settles a connection the server closes after DATA at `unfiled`, sending once", async () => {
+		w.close();
+		w = await openWorld({ dropAfterData: true });
+		const a = await arrange(w);
+
+		await handleSendMessage(a.event, w.ctx, 1);
+
+		const row = await outboxRow(w, a);
+		assert.equal(row.status, OutboxMessageStatus.unfiled);
+		assert.match(String(row.lastError), /may already have been delivered/);
+		assert.equal(
+			w.smtp.received.filter((chunk) => chunk.includes("\r\n.\r\n")).length,
+			1,
+		);
+		assert.deepEqual(w.failures, ["network"]);
+	});
 
 	it("settles an exhausted transient SMTP refusal at `failed` instead of leaving it `queued` forever", async () => {
 		w.close();

package/src/handlers/send-message.ts

@@ -148,35 +148,6 @@ const REAUTH_REQUIRED =
 const UNFILED_CONNECTION_LOST =
 	"The connection to the outgoing server dropped during the send, so this message may already have been delivered. Check with the recipient before sending it again.";
 
-/**
- * The connection failures that prove nothing was submitted: no session ever
- * opened, so the server holds no copy and `failed` is safe — Retry sends the
- * only copy there is.
- *
- * `ECONNRESET` and `ETIMEDOUT` classify as `network` too and are deliberately
- * absent. Either can land after DATA, with the message already queued on the
- * server, and a `failed` row invites a Retry that delivers it twice.
- */
-const NEVER_SUBMITTED_CODES: ReadonlySet<string> = new Set([
-	"ECONNREFUSED",
-	"ENOTFOUND",
-	"EHOSTUNREACH",
-]);
-
-const errorCode = (cause: unknown): string =>
-	cause instanceof Error && "code" in cause && typeof cause.code === "string"
-		? cause.code
-		: "";
-
-/**
- * Whether the message can be re-sent without risking a second copy. An auth
- * rejection is decided before the envelope; a connection failure carries the
- * code that says how far it got. Anything else counts as possibly delivered,
- * which is the answer that cannot produce a duplicate.
- */
-const neverSubmitted = (err: SmtpConnectionError): boolean =>
-	err.kind === "auth" || NEVER_SUBMITTED_CODES.has(errorCode(err.cause));
-
 const SENDABLE_STATUSES: ReadonlySet<OutboxMessageItem["status"]> = new Set([
 	OutboxMessageStatus.draft,
 	OutboxMessageStatus.queued,
@@ -408,27 +379,18 @@ export const handleSendMessage = async (
 			await settleBlockedOnReauth(OutboxMessageStatus.sending);
 			return; // ACK — do not retry
 		}
-		// A password account's auth failure and every network failure retry on
-		// SQS redelivery until the queue's own budget runs out, then settle
-		// here instead of dead-lettering with the row stuck at `sending`
-		// (issue #951). Where it settles is the double-send question:
-		// `neverSubmitted` says the message cannot be on the server, so
-		// `failed` offers the Retry the user needs; anything else settles
-		// `unfiled`, the state that says a copy may be out there and which
-		// Retry is not offered on. Wait-or-reconcile
-		// (docs/architecture/imap-mutations.md R2): neither applies — a
-		// submission leaves no server-side handle to reconcile against, so the
-		// row settles on what the failure itself proves.
+		// Once the whole message is written the server may hold a copy, so a
+		// redelivery or a Retry could deliver it twice.
 		if (err instanceof SmtpConnectionError) {
-			if (receiveCount < ctx.maxAttempts) {
+			if (!err.afterData && receiveCount < ctx.maxAttempts) {
 				throw err;
 			}
-			const settled = neverSubmitted(err)
-				? { status: OutboxMessageStatus.failed, lastError: err.message }
-				: {
+			const settled = err.afterData
+				? {
 						status: OutboxMessageStatus.unfiled,
 						lastError: `${UNFILED_CONNECTION_LOST} (${err.message})`,
-					};
+					}
+				: { status: OutboxMessageStatus.failed, lastError: err.message };
 			await ports.outboxMessage.update(
 				accountConfigId,
 				outboxMessageId,
@@ -444,7 +406,7 @@ export const handleSendMessage = async (
 					receiveCount,
 					status: settled.status,
 				},
-				"SMTP send retry exhausted; settling the row",
+				"SMTP connection failed; settling the row",
 			);
 			return; // ACK — settled terminal, no more retries
 		}