@remit/smtp-service 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remit/smtp-service",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "main": "src/index.ts",
   "exports": {
@@ -16,14 +16,13 @@
   "scripts": {
     "test:typecheck": "tsgo --noEmit",
     "test:run": "node $NODE_TEST_FLAGS --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=95 --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'"
+    "test": "npm run test:typecheck && npm run test:run"
   },
   "devDependencies": {
     "@types/node": "*"
   },
   "dependencies": {
-    "nodemailer": "^9.0.3",
+    "nodemailer": "^10.0.6",
     "@remit/data-ports": "*",
     "@types/nodemailer": "*"
   },

package/src/message-builder.test.ts

@@ -99,6 +99,17 @@ describe("buildMailMessage", () => {
 		assert.equal(message.inReplyTo, "<parent@example.com>");
 	});
 
+	it("puts exactly one pair of brackets on an id stored with its own", () => {
+		const message = buildMailMessage(
+			baseOutbox({
+				inReplyTo: "<parent@example.com>",
+				references: ["<<root@example.com>>", "<parent@example.com>"],
+			}),
+		);
+		assert.equal(message.inReplyTo, "<parent@example.com>");
+		assert.equal(message.references, "<root@example.com> <parent@example.com>");
+	});
+
 	it("leaves inReplyTo undefined when absent", () => {
 		const message = buildMailMessage(baseOutbox({ inReplyTo: undefined }));
 		assert.equal(message.inReplyTo, undefined);
@@ -132,7 +143,7 @@ describe("buildMailMessage", () => {
 			},
 		];
 		const message = buildMailMessage(baseOutbox(), attachments);
-		assert.equal(message.attachments, attachments);
+		assert.deepEqual(message.attachments, attachments);
 	});
 
 	it("leaves attachments undefined when none are provided", () => {
@@ -257,6 +268,53 @@ describe("renderRawMessage", () => {
 		assert.ok(raw.includes(Buffer.from("png-bytes").toString("base64")));
 	});
 
+	it("puts a file the html body refers to inline, next to the html", async () => {
+		const raw = String(
+			await renderRawMessage(
+				buildMailMessage(
+					baseOutbox({
+						textBody: "see below",
+						htmlBody: '<p>see below</p><p><img src="cid:shot-1@remit"></p>',
+					}),
+					[
+						{
+							filename: "shot.png",
+							content: Buffer.from("png-bytes"),
+							contentType: "image/png",
+							cid: "shot-1@remit",
+						},
+					],
+				),
+			),
+		);
+
+		assert.match(raw, /Content-Type: multipart\/related; type="text\/html"/);
+		assert.match(raw, /Content-Disposition: inline; filename=shot\.png/);
+		assert.match(raw, /Content-ID: <shot-1@remit>/);
+	});
+
+	it("sends a file the html body does not refer to as an ordinary attachment", async () => {
+		const raw = String(
+			await renderRawMessage(
+				buildMailMessage(
+					baseOutbox({ textBody: "attached", htmlBody: "<p>attached</p>" }),
+					[
+						{
+							filename: "photo.png",
+							content: Buffer.from("png-bytes"),
+							contentType: "image/png",
+							cid: "photo-1@remit",
+						},
+					],
+				),
+			),
+		);
+
+		assert.match(raw, /Content-Disposition: attachment; filename=photo\.png/);
+		assert.ok(!raw.includes("Content-ID"));
+		assert.ok(!raw.includes("multipart/related"));
+	});
+
 	it("dates the rendered copy from the moment the send was recorded", async () => {
 		const raw = String(
 			await renderRawMessage(

package/src/message-builder.ts

@@ -1,4 +1,5 @@
 import type { OutboxMessageItem } from "@remit/data-ports";
+import { wireMessageId } from "@remit/data-ports/id";
 import nodemailer, { type SendMailOptions } from "nodemailer";
 
 export interface MailMessage {
@@ -30,6 +31,18 @@ export interface MailAttachment {
 const formatFrom = (address: string, name: string | undefined): string =>
 	name ? `"${name.replace(/(["\\])/g, "\\$1")}" <${address}>` : address;
 
+const placeAttachment = (
+	attachment: MailAttachment,
+	html: string | undefined,
+): MailAttachment => {
+	if (!attachment.cid || attachment.contentDisposition) return attachment;
+	if (html?.includes(`cid:${attachment.cid}`)) {
+		return { ...attachment, contentDisposition: "inline" };
+	}
+	const { cid: _unreferenced, ...standalone } = attachment;
+	return standalone;
+};
+
 /** The one description of an outgoing message: the wire copy and the Sent copy. */
 export const buildMailMessage = (
 	outbox: OutboxMessageItem,
@@ -43,14 +56,16 @@ export const buildMailMessage = (
 	subject: outbox.subject,
 	text: outbox.textBody,
 	html: outbox.htmlBody,
-	messageId: `<${outbox.messageIdValue}>`,
-	inReplyTo: outbox.inReplyTo ? `<${outbox.inReplyTo}>` : undefined,
-	references: outbox.references?.map((r) => `<${r}>`).join(" "),
+	messageId: wireMessageId(outbox.messageIdValue),
+	inReplyTo: outbox.inReplyTo ? wireMessageId(outbox.inReplyTo) : undefined,
+	references: outbox.references?.map(wireMessageId).join(" "),
 	// Only the Sent copy has one to carry: the row is stamped after the
 	// submission is accepted, so on the wire path this is always absent and
 	// nodemailer dates the message as it goes out.
 	date: outbox.sentAt ? new Date(outbox.sentAt) : undefined,
-	attachments,
+	attachments: attachments?.map((attachment) =>
+		placeAttachment(attachment, outbox.htmlBody),
+	),
 });
 
 export const toNodemailerOptions = (message: MailMessage): SendMailOptions => ({

package/src/smtp-client.integ.test.ts

@@ -1,240 +0,0 @@
-/**
- * Integration tests for SMTP client using mokapi.
- *
- * These tests require mokapi to be running:
- *   npm run start:mokapi
- *
- * Run with:
- *   npm run test:integ -w packages/smtp-service
- *
- * Note: mokapi SMTP server runs on port 2525 without TLS.
- * Sent emails are delivered to the recipient's IMAP mailbox.
- */
-
-import assert from "node:assert";
-import { describe, test } from "node:test";
-import type { MailMessage } from "./message-builder.js";
-import { generateMessageId } from "./message-id.js";
-import { type SmtpConfig, sendMail } from "./smtp-client.js";
-
-const MOKAPI_SMTP_CONFIG: SmtpConfig = {
-	host: "localhost",
-	port: 2525,
-	secure: false,
-	user: "alice@mokapi.io",
-	credentials: { kind: "password", password: "alice123" },
-	tls: {
-		rejectUnauthorized: false, // Accept mokapi's self-signed cert
-	},
-};
-
-/**
- * Generate a unique message ID for testing
- */
-const createTestMessageId = (): string => {
-	return `<${generateMessageId("mokapi.io")}>`;
-};
-
-/**
- * Create a basic test message
- */
-const createTestMessage = (
-	overrides: Partial<MailMessage> = {},
-): MailMessage => {
-	return {
-		from: "alice@mokapi.io",
-		to: ["bob@mokapi.io"],
-		subject: `Test message ${Date.now()}`,
-		text: "This is a test message body.",
-		messageId: createTestMessageId(),
-		...overrides,
-	};
-};
-
-describe("SMTP client integration tests", {
-	skip: !process.env.RUN_INTEG_TESTS,
-}, () => {
-	describe("sendMail", () => {
-		test("sends a simple text message", async () => {
-			const message = createTestMessage({
-				subject: `Simple text test ${Date.now()}`,
-				text: "Hello from the SMTP integration test!",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.equal(result.isTransient, false, "Should not be transient");
-			assert.ok(result.messageId, "Should return a message ID");
-			assert.ok(result.response, "Should return an SMTP response");
-		});
-
-		test("sends an HTML message", async () => {
-			const message = createTestMessage({
-				subject: `HTML test ${Date.now()}`,
-				text: "Plain text fallback",
-				html: "<html><body><h1>Hello!</h1><p>This is an <strong>HTML</strong> message.</p></body></html>",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a message with CC recipients", async () => {
-			const message = createTestMessage({
-				subject: `CC test ${Date.now()}`,
-				to: ["bob@mokapi.io"],
-				cc: ["alice@mokapi.io"],
-				text: "Message with CC recipient",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a message with BCC recipients", async () => {
-			const message = createTestMessage({
-				subject: `BCC test ${Date.now()}`,
-				to: ["bob@mokapi.io"],
-				bcc: ["alice@mokapi.io"],
-				text: "Message with BCC recipient",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a message with multiple recipients", async () => {
-			const message = createTestMessage({
-				subject: `Multiple recipients test ${Date.now()}`,
-				to: ["bob@mokapi.io", "alice@mokapi.io"],
-				text: "Message to multiple recipients",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a reply with In-Reply-To header", async () => {
-			const originalMessageId = "<original-message-123@mokapi.io>";
-			const message = createTestMessage({
-				subject: `Re: Original subject ${Date.now()}`,
-				text: "This is a reply to your message.",
-				inReplyTo: originalMessageId,
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a reply with References header", async () => {
-			const references = [
-				"<msg-1@mokapi.io>",
-				"<msg-2@mokapi.io>",
-				"<msg-3@mokapi.io>",
-			].join(" ");
-
-			const message = createTestMessage({
-				subject: `Re: Thread subject ${Date.now()}`,
-				text: "This is a reply in a thread.",
-				inReplyTo: "<msg-3@mokapi.io>",
-				references,
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a message with Reply-To address", async () => {
-			const message = createTestMessage({
-				subject: `Reply-To test ${Date.now()}`,
-				text: "Please reply to a different address.",
-				replyTo: "noreply@mokapi.io",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("sends a message with formatted From name", async () => {
-			const message = createTestMessage({
-				from: '"Alice Test" <alice@mokapi.io>',
-				subject: `From name test ${Date.now()}`,
-				text: "Message with formatted From name",
-			});
-
-			const result = await sendMail(MOKAPI_SMTP_CONFIG, message);
-
-			assert.equal(result.success, true, "Send should succeed");
-			assert.ok(result.messageId, "Should return a message ID");
-		});
-
-		test("handles connection failure gracefully", async () => {
-			const badConfig: SmtpConfig = {
-				host: "localhost",
-				port: 9999, // Non-existent port
-				secure: false,
-				user: "alice@mokapi.io",
-				credentials: { kind: "password", password: "alice123" },
-				connectionTimeout: 1000, // Short timeout for tests
-			};
-
-			const message = createTestMessage();
-			const result = await sendMail(badConfig, message);
-
-			assert.equal(result.success, false, "Send should fail");
-			assert.ok(result.error, "Should return an error");
-			// Connection errors are typically transient
-			assert.equal(
-				result.isTransient,
-				false,
-				"Connection errors without SMTP code are not transient",
-			);
-		});
-
-		test("handles authentication failure", async () => {
-			const badAuthConfig: SmtpConfig = {
-				host: "localhost",
-				port: 2525,
-				secure: false,
-				user: "alice@mokapi.io",
-				credentials: { kind: "password", password: "wrong-password" },
-				tls: {
-					rejectUnauthorized: false,
-				},
-				connectionTimeout: 5000,
-			};
-
-			const message = createTestMessage();
-			const result = await sendMail(badAuthConfig, message);
-
-			// mokapi may or may not enforce authentication
-			// If it does, this should fail; if not, it will succeed
-			if (!result.success) {
-				assert.ok(result.error, "Should return an error");
-				// 5xx errors are permanent (not transient)
-				if (result.smtpCode && result.smtpCode >= 500) {
-					assert.equal(
-						result.isTransient,
-						false,
-						"Auth failure should be permanent",
-					);
-				}
-			}
-		});
-	});
-});