@remit/smtp-service 0.0.5 → 0.0.7

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@remit/smtp-service",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "main": "src/index.ts",
   "scripts": {
     "test:typecheck": "tsgo --noEmit",
-    "test:run": "node --env-file=../../localhost-test-unit.env --test 'src/**/*.test.ts'",
+    "test:run": "node --env-file=../../localhost-test-unit.env --experimental-test-coverage --test-coverage-include='src/**' --test-coverage-exclude='src/**/*.test.ts' --test-coverage-exclude='src/**/*.test.tsx' --test-coverage-lines=70 --test 'src/**/*.test.ts'",
     "test": "npm run test:typecheck && npm run test:run",
     "test:integ": "RUN_INTEG_TESTS=true node --env-file=../../localhost-dev-aws.env --import tsx --test --test-force-exit 'src/**/*.integ.test.ts'"
   },

package/src/message-builder.test.ts

@@ -0,0 +1,117 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import type { OutboxMessageItem } from "@remit/data-ports";
+import { buildMailMessage, type MailAttachment } from "./message-builder.js";
+
+const baseOutbox = (
+	overrides: Partial<OutboxMessageItem> = {},
+): OutboxMessageItem => ({
+	outboxMessageId: "outbox-1",
+	accountId: "account-1",
+	accountConfigId: "config-1",
+	fromAddress: "sender@example.com",
+	toAddresses: ["to@example.com"],
+	ccAddresses: [],
+	bccAddresses: [],
+	messageIdValue: "generated-id@example.com",
+	references: [],
+	status: "queued",
+	createdAt: 1_700_000_000_000,
+	updatedAt: 1_700_000_000_000,
+	...overrides,
+});
+
+describe("buildMailMessage", () => {
+	it("formats From as a quoted display name when fromName is set", () => {
+		const message = buildMailMessage(
+			baseOutbox({
+				fromName: "Alice Sender",
+				fromAddress: "alice@example.com",
+			}),
+		);
+		assert.equal(message.from, '"Alice Sender" <alice@example.com>');
+	});
+
+	it("uses the bare address as From when fromName is absent", () => {
+		const message = buildMailMessage(
+			baseOutbox({ fromName: undefined, fromAddress: "alice@example.com" }),
+		);
+		assert.equal(message.from, "alice@example.com");
+	});
+
+	it("wraps messageIdValue in angle brackets", () => {
+		const message = buildMailMessage(
+			baseOutbox({ messageIdValue: "abc.123@example.com" }),
+		);
+		assert.equal(message.messageId, "<abc.123@example.com>");
+	});
+
+	it("carries recipient and body fields through unchanged", () => {
+		const message = buildMailMessage(
+			baseOutbox({
+				toAddresses: ["a@example.com", "b@example.com"],
+				ccAddresses: ["c@example.com"],
+				bccAddresses: ["d@example.com"],
+				replyToAddress: "reply@example.com",
+				subject: "Hello",
+				textBody: "plain text",
+				htmlBody: "<p>html</p>",
+			}),
+		);
+		assert.deepEqual(message.to, ["a@example.com", "b@example.com"]);
+		assert.deepEqual(message.cc, ["c@example.com"]);
+		assert.deepEqual(message.bcc, ["d@example.com"]);
+		assert.equal(message.replyTo, "reply@example.com");
+		assert.equal(message.subject, "Hello");
+		assert.equal(message.text, "plain text");
+		assert.equal(message.html, "<p>html</p>");
+	});
+
+	it("wraps inReplyTo in angle brackets when present", () => {
+		const message = buildMailMessage(
+			baseOutbox({ inReplyTo: "parent@example.com" }),
+		);
+		assert.equal(message.inReplyTo, "<parent@example.com>");
+	});
+
+	it("leaves inReplyTo undefined when absent", () => {
+		const message = buildMailMessage(baseOutbox({ inReplyTo: undefined }));
+		assert.equal(message.inReplyTo, undefined);
+	});
+
+	it("angle-brackets each reference and joins them with spaces", () => {
+		const message = buildMailMessage(
+			baseOutbox({ references: ["one@example.com", "two@example.com"] }),
+		);
+		assert.equal(message.references, "<one@example.com> <two@example.com>");
+	});
+
+	it("produces an empty references string when there are none", () => {
+		const message = buildMailMessage(baseOutbox({ references: [] }));
+		assert.equal(message.references, "");
+	});
+
+	it("passes attachments through to the built message", () => {
+		const attachments: MailAttachment[] = [
+			{
+				filename: "invoice.pdf",
+				content: Buffer.from("pdf-bytes"),
+				contentType: "application/pdf",
+			},
+			{
+				filename: "logo.png",
+				content: Buffer.from("png-bytes"),
+				contentType: "image/png",
+				cid: "logo-cid",
+				contentDisposition: "inline",
+			},
+		];
+		const message = buildMailMessage(baseOutbox(), attachments);
+		assert.equal(message.attachments, attachments);
+	});
+
+	it("leaves attachments undefined when none are provided", () => {
+		const message = buildMailMessage(baseOutbox());
+		assert.equal(message.attachments, undefined);
+	});
+});

package/src/smtp-client.test.ts

@@ -0,0 +1,209 @@
+import assert from "node:assert/strict";
+import net from "node:net";
+import { after, describe, it } from "node:test";
+import type { MailMessage } from "./message-builder.js";
+import {
+	type SmtpConfig,
+	SmtpConnectionError,
+	type SmtpCredentials,
+	sendMail,
+} from "./smtp-client.js";
+
+interface FakeSmtpOptions {
+	authResponse?: string;
+	dataFinalResponse?: string;
+	dropAfterGreeting?: boolean;
+}
+
+interface FakeSmtp {
+	port: number;
+	authCommands: string[];
+	close: () => void;
+}
+
+const startFakeSmtp = (opts: FakeSmtpOptions = {}): Promise<FakeSmtp> =>
+	new Promise((resolve) => {
+		const authCommands: string[] = [];
+		const server = net.createServer((socket) => {
+			if (opts.dropAfterGreeting) {
+				socket.destroy();
+				return;
+			}
+			socket.write("220 fake ESMTP\r\n");
+			let inData = false;
+			socket.on("data", (buffer) => {
+				const line = buffer.toString();
+				if (inData) {
+					if (line.includes("\r\n.\r\n")) {
+						inData = false;
+						socket.write(opts.dataFinalResponse ?? "250 2.0.0 Ok\r\n");
+					}
+					return;
+				}
+				const command = line.slice(0, 4).toUpperCase();
+				if (command.startsWith("EHLO") || command.startsWith("HELO")) {
+					socket.write("250-fake\r\n250 AUTH PLAIN LOGIN XOAUTH2\r\n");
+					return;
+				}
+				if (command.startsWith("AUTH")) {
+					authCommands.push(line.trim());
+					socket.write(opts.authResponse ?? "235 2.7.0 Accepted\r\n");
+					return;
+				}
+				if (command.startsWith("MAIL") || command.startsWith("RCPT")) {
+					socket.write("250 2.1.0 Ok\r\n");
+					return;
+				}
+				if (command.startsWith("DATA")) {
+					socket.write("354 End data\r\n");
+					inData = true;
+					return;
+				}
+				if (command.startsWith("QUIT")) {
+					socket.write("221 Bye\r\n");
+					socket.end();
+					return;
+				}
+				socket.write("250 Ok\r\n");
+			});
+		});
+		server.listen(0, "127.0.0.1", () => {
+			const address = server.address();
+			const port = typeof address === "object" && address ? address.port : 0;
+			resolve({
+				port,
+				authCommands,
+				close: () => server.close(),
+			});
+		});
+	});
+
+const configFor = (
+	port: number,
+	credentials: SmtpCredentials = { kind: "password", password: "secret" },
+): SmtpConfig => ({
+	host: "127.0.0.1",
+	port,
+	secure: false,
+	user: "user@example.com",
+	credentials,
+	connectionTimeout: 2000,
+});
+
+const testMessage: MailMessage = {
+	from: "user@example.com",
+	to: ["recipient@example.com"],
+	subject: "Subject",
+	text: "Body",
+	messageId: "<message@example.com>",
+};
+
+describe("sendMail", () => {
+	const servers: FakeSmtp[] = [];
+	const spawn = async (opts?: FakeSmtpOptions): Promise<FakeSmtp> => {
+		const server = await startFakeSmtp(opts);
+		servers.push(server);
+		return server;
+	};
+
+	after(() => {
+		for (const server of servers) {
+			server.close();
+		}
+	});
+
+	it("returns success with the SMTP response on delivery", async () => {
+		const server = await spawn();
+		const result = await sendMail(configFor(server.port), testMessage);
+
+		assert.equal(result.success, true);
+		assert.equal(result.isTransient, false);
+		assert.ok(result.response);
+	});
+
+	it("sends attachments through the transport", async () => {
+		const server = await spawn();
+		const result = await sendMail(configFor(server.port), {
+			...testMessage,
+			html: "<p>hi</p>",
+			cc: ["cc@example.com"],
+			bcc: ["bcc@example.com"],
+			replyTo: "reply@example.com",
+			inReplyTo: "<parent@example.com>",
+			references: "<a@example.com> <b@example.com>",
+			attachments: [
+				{
+					filename: "note.txt",
+					content: Buffer.from("hello"),
+					contentType: "text/plain",
+					contentDisposition: "attachment",
+				},
+			],
+		});
+
+		assert.equal(result.success, true);
+	});
+
+	it("uses XOAUTH2 for access-token credentials", async () => {
+		const server = await spawn();
+		const result = await sendMail(
+			configFor(server.port, { kind: "accessToken", accessToken: "token-abc" }),
+			testMessage,
+		);
+
+		assert.equal(result.success, true);
+		assert.ok(
+			server.authCommands.some((command) => command.startsWith("AUTH XOAUTH2")),
+			"expected an AUTH XOAUTH2 command",
+		);
+	});
+
+	it("throws a classified auth error on a 535 AUTH rejection", async () => {
+		const server = await spawn({
+			authResponse: "535 5.7.8 Authentication credentials invalid\r\n",
+		});
+
+		await assert.rejects(
+			sendMail(configFor(server.port), testMessage),
+			(error: unknown) => {
+				assert.ok(error instanceof SmtpConnectionError);
+				assert.equal(error.kind, "auth");
+				assert.equal(error.message, "SMTP authentication failed");
+				return true;
+			},
+		);
+	});
+
+	it("treats a 5xx delivery rejection as a permanent failure", async () => {
+		const server = await spawn({
+			dataFinalResponse: "550 5.0.0 Rejected\r\n",
+		});
+		const result = await sendMail(configFor(server.port), testMessage);
+
+		assert.equal(result.success, false);
+		assert.equal(result.smtpCode, 550);
+		assert.equal(result.isTransient, false);
+		assert.ok(result.error);
+	});
+
+	it("treats a 4xx delivery rejection as a transient failure", async () => {
+		const server = await spawn({
+			dataFinalResponse: "451 4.3.0 Try again later\r\n",
+		});
+		const result = await sendMail(configFor(server.port), testMessage);
+
+		assert.equal(result.success, false);
+		assert.equal(result.smtpCode, 451);
+		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);
+
+		assert.equal(result.success, false);
+		assert.equal(result.isTransient, false);
+		assert.equal(result.smtpCode, undefined);
+		assert.ok(result.error);
+	});
+});