@remit/smtp-service 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@remit/smtp-service",
-	"version": "1.0.3",
+	"version": "1.0.4",
 	"type": "module",
 	"main": "src/index.ts",
 	"exports": {

package/src/smtp-client.test.ts

@@ -167,14 +167,28 @@ describe("sendMail", () => {
 		assert.equal(result.isTransient, true);
 	});
 
-	it("returns a non-transient failure when the socket errors without an SMTP code", async () => {
-		const server = await spawn({ dropAfterGreeting: true });
-		const result = await sendMail(configFor(server.port), testMessage);
+	it("throws a network SmtpConnectionError before data when the server drops before the greeting", async () => {
+		const server = await spawn({ dropBeforeGreeting: true });
 
-		assert.equal(result.success, false);
-		assert.equal(result.isTransient, false);
-		assert.equal(result.smtpCode, undefined);
-		assert.ok(result.error);
+		await assert.rejects(
+			() => sendMail(configFor(server.port), testMessage),
+			(error: unknown) =>
+				error instanceof SmtpConnectionError &&
+				error.kind === "network" &&
+				!error.afterData,
+		);
+	});
+
+	it("marks a drop after the whole message was written as after data", async () => {
+		const server = await spawn({ dropAfterData: true });
+
+		await assert.rejects(
+			() => sendMail(configFor(server.port), testMessage),
+			(error: unknown) =>
+				error instanceof SmtpConnectionError &&
+				error.kind === "network" &&
+				error.afterData,
+		);
 	});
 });
 

package/src/smtp-client.ts

@@ -25,11 +25,19 @@ export type SmtpErrorKind = "auth" | "network";
  */
 export class SmtpConnectionError extends Error {
 	readonly kind: SmtpErrorKind;
+	/** The whole message, end-of-data included, was written before it failed. */
+	readonly afterData: boolean;
 
-	constructor(kind: SmtpErrorKind, message: string, cause?: unknown) {
+	constructor(
+		kind: SmtpErrorKind,
+		message: string,
+		cause?: unknown,
+		afterData = false,
+	) {
 		super(message, { cause });
 		this.name = "SmtpConnectionError";
 		this.kind = kind;
+		this.afterData = afterData;
 	}
 }
 
@@ -95,19 +103,59 @@ type SmtpFailure = Error & {
 	code?: string;
 	command?: string;
 	response?: string;
+	originalCode?: string;
 };
 
+/**
+ * nodemailer's own codes for a connection that failed. It moves the system
+ * code (`ECONNRESET`, `ECONNREFUSED`) to `originalCode`.
+ */
 const NETWORK_ERROR_CODES = new Set([
-	"ECONNREFUSED",
+	"ECONNECTION",
+	"ESOCKET",
 	"ETIMEDOUT",
-	"ENOTFOUND",
-	"ECONNRESET",
-	"EHOSTUNREACH",
+	"EDNS",
+	"ETLS",
 ]);
 
+const noop = (): void => undefined;
+
+/**
+ * A nodemailer logger that only records whether the whole message, end of
+ * data included, was written to the socket: the one point after which the
+ * server may hold a copy.
+ */
+const dataWatch = () => {
+	const watch = {
+		afterData: false,
+		logger: {
+			trace: noop,
+			debug: noop,
+			warn: noop,
+			error: noop,
+			fatal: noop,
+			info: (entry: unknown) => {
+				if (
+					typeof entry === "object" &&
+					entry !== null &&
+					"tnx" in entry &&
+					entry.tnx === "message"
+				) {
+					watch.afterData = true;
+				}
+			},
+		},
+	};
+	return watch;
+};
+
 const VERIFY_TIMEOUT_MS = 12_000;
 
-const transporterFor = (config: SmtpConfig, socketTimeout: number) => {
+const transporterFor = (
+	config: SmtpConfig,
+	socketTimeout: number,
+	logger: ReturnType<typeof dataWatch>["logger"] | false = false,
+) => {
 	const timeout = config.connectionTimeout ?? 30_000;
 	return nodemailer.createTransport({
 		host: config.host,
@@ -119,10 +167,14 @@ const transporterFor = (config: SmtpConfig, socketTimeout: number) => {
 		greetingTimeout: timeout,
 		socketTimeout,
 		getSocket: config.getSocket,
+		logger,
 	});
 };
 
-const classifySmtpError = (error: SmtpFailure): SmtpConnectionError | null => {
+const classifySmtpError = (
+	error: SmtpFailure,
+	afterData = false,
+): SmtpConnectionError | null => {
 	const smtpCode = error.responseCode;
 
 	if (
@@ -145,8 +197,9 @@ const classifySmtpError = (error: SmtpFailure): SmtpConnectionError | null => {
 	if (error.code !== undefined && NETWORK_ERROR_CODES.has(error.code)) {
 		return new SmtpConnectionError(
 			"network",
-			`SMTP connection failed: ${error.code}`,
+			`SMTP connection failed: ${error.originalCode ?? error.code}`,
 			error,
+			afterData,
 		);
 	}
 
@@ -160,7 +213,8 @@ export const sendMail = async (
 	config: SmtpConfig,
 	message: MailMessage,
 ): Promise<SendResult> => {
-	const transporter = transporterFor(config, 300_000);
+	const watch = dataWatch();
+	const transporter = transporterFor(config, 300_000, watch.logger);
 
 	return transporter
 		.sendMail(toNodemailerOptions(message))
@@ -171,7 +225,7 @@ export const sendMail = async (
 			isTransient: false,
 		}))
 		.catch((error: SmtpFailure) => {
-			const classified = classifySmtpError(error);
+			const classified = classifySmtpError(error, watch.afterData);
 			if (classified) {
 				throw classified;
 			}

package/src/test-fake-smtp.ts

@@ -3,7 +3,8 @@ import net from "node:net";
 export interface FakeSmtpOptions {
 	authResponse?: string;
 	dataFinalResponse?: string;
-	dropAfterGreeting?: boolean;
+	dropBeforeGreeting?: boolean;
+	dropAfterData?: boolean;
 }
 
 export interface FakeSmtp {
@@ -18,7 +19,7 @@ export const startFakeSmtp = (opts: FakeSmtpOptions = {}): Promise<FakeSmtp> =>
 		const authCommands: string[] = [];
 		const received: string[] = [];
 		const server = net.createServer((socket) => {
-			if (opts.dropAfterGreeting) {
+			if (opts.dropBeforeGreeting) {
 				socket.destroy();
 				return;
 			}
@@ -30,6 +31,10 @@ export const startFakeSmtp = (opts: FakeSmtpOptions = {}): Promise<FakeSmtp> =>
 					received.push(line);
 					if (line.includes("\r\n.\r\n")) {
 						inData = false;
+						if (opts.dropAfterData) {
+							socket.destroy();
+							return;
+						}
 						socket.write(opts.dataFinalResponse ?? "250 2.0.0 Ok\r\n");
 					}
 					return;