mailchannels-sdk 1.3.1 → 1.4.0

package/dist/plugins/nodemailer/index.d.mts

@@ -0,0 +1,33 @@
+import { EmailsQueueResponse, EmailsSendOptions, EmailsSendResponse, MailChannelsClientOptions } from "../../_chunks/mailchannels.mjs";
+import { Transport as Transport$1 } from "nodemailer";
+import MimeNode from "nodemailer/lib/mime-node";
+type MailChannelsTransportSendOptions = Pick<EmailsSendOptions, "campaignId" | "tracking" | "transactional" | "unsubscribe">;
+type MailChannelsTransportSendMode = "sync" | "async";
+interface MailChannelsTransportOptions<T extends MailChannelsTransportSendMode = "async"> extends MailChannelsClientOptions {
+  /**
+   * The MailChannels Email API key.
+   */
+  apiKey: string;
+  /**
+   * The mode in which emails are sent.
+   * @default "async"
+   */
+  sendMode?: T;
+}
+interface MailChannelsTransportInfo<T extends MailChannelsTransportSendMode> {
+  messageId: string | null;
+  accepted: string[];
+  rejected: string[];
+  envelope: MimeNode.Envelope;
+  response: (T extends "sync" ? EmailsSendResponse : EmailsQueueResponse) | null;
+}
+declare module "nodemailer" {
+  function createTransport<T>(transport: Transport<T> | TransportOptions, defaults?: TransportOptions): Transporter<T, TransportOptions>;
+}
+declare module "nodemailer/lib/mailer" {
+  interface Options {
+    mailchannels?: MailChannelsTransportSendOptions;
+  }
+}
+declare const mailchannelsTransport: <T extends MailChannelsTransportSendMode = "async">(options: MailChannelsTransportOptions<T>) => Transport$1<MailChannelsTransportInfo<T>>;
+export { MailChannelsTransportInfo, MailChannelsTransportOptions, MailChannelsTransportSendMode, MailChannelsTransportSendOptions, mailchannelsTransport };

package/dist/plugins/nodemailer/index.mjs

@@ -0,0 +1,145 @@
+import { Emails, MailChannelsClient, version } from "../../_chunks/mailchannels.mjs";
+import { createPrivateKey } from "node:crypto";
+import { Buffer } from "node:buffer";
+const parseAddress = (address) => {
+	if (!address) return "";
+	if (Array.isArray(address)) return parseAddress(address[0]);
+	if (typeof address === "string") return address;
+	return {
+		email: address.address,
+		name: address.name || void 0
+	};
+};
+const parseAddresses = (addresses) => {
+	if (!addresses) return [];
+	if (typeof addresses === "string") return addresses.split(",").map((s) => s.trim()).filter(Boolean);
+	if (Array.isArray(addresses)) return addresses.map((address) => parseAddress(address));
+	if (typeof addresses === "object" && addresses.address) return [{
+		email: addresses.address,
+		name: addresses.name || void 0
+	}];
+	return [];
+};
+const parseAttachments = (attachments) => {
+	if (!attachments) return;
+	return attachments.map((attachment) => {
+		if (!attachment.filename || attachment.content === void 0) throw new Error("Attachment is missing filename or content");
+		if (typeof attachment.content === "string") {
+			const encoding = attachment.encoding || "utf-8";
+			return {
+				content: encoding === "base64" ? attachment.content : Buffer.from(attachment.content, encoding).toString("base64"),
+				filename: decodeURIComponent(attachment.filename),
+				type: attachment.contentType,
+				contentId: attachment.cid
+			};
+		}
+		throw new Error("Attachment content must be a string or Buffer");
+	});
+};
+const parseDkim = (dkim) => {
+	if (!dkim) return;
+	if ("keys" in dkim) throw new Error("Multiple DKIM signatures are not supported");
+	let privateKey;
+	if (typeof dkim.privateKey === "string") privateKey = dkim.privateKey;
+	else if (dkim.privateKey?.key && dkim.privateKey?.passphrase) try {
+		privateKey = createPrivateKey({
+			key: dkim.privateKey.key,
+			passphrase: dkim.privateKey.passphrase
+		}).export({
+			format: "pem",
+			type: "pkcs1"
+		});
+	} catch (error) {
+		if (error.code === "ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS") throw new Error("Only RSA private keys are supported for DKIM signing");
+		throw error;
+	}
+	return {
+		selector: dkim.keySelector,
+		privateKey,
+		domain: dkim.domainName
+	};
+};
+const parseHeaders = (headers) => {
+	if (!headers) return;
+	if (Array.isArray(headers)) return headers.reduce((acc, { key, value }) => {
+		acc[key] = value;
+		return acc;
+	}, {});
+	return Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, Array.isArray(value) ? value.join(",") : value && typeof value === "object" && "value" in value ? String(value.value) : String(value)]));
+};
+const parseIcalEvent = (icalEvent) => {
+	if (typeof icalEvent === "string") return {
+		content: Buffer.from(icalEvent).toString("base64"),
+		filename: "invite.ics",
+		type: "text/calendar"
+	};
+	if (typeof icalEvent === "object" && icalEvent && "content" in icalEvent) return parseAttachments([{
+		filename: icalEvent.filename || "invite.ics",
+		content: icalEvent.content,
+		encoding: icalEvent.encoding,
+		contentType: "text/calendar"
+	}])[0];
+	throw new Error("Not supported icalEvent format");
+};
+const mailchannelsTransport = (options) => {
+	const { apiKey = "", sendMode = "async", ...clientOptions } = options;
+	const client = new MailChannelsClient(apiKey, clientOptions);
+	const emails = new Emails(client);
+	const sendMail = sendMode === "sync" ? emails.send.bind(emails) : emails.queue.bind(emails);
+	return {
+		name: "MailChannelsTransport",
+		version,
+		send(mail, callback) {
+			const sentMessageInfo = {
+				messageId: null,
+				accepted: [],
+				rejected: [],
+				envelope: mail.message.getEnvelope(),
+				response: null
+			};
+			mail.normalize(async (err, data) => {
+				if (!data || err) return callback(err || /* @__PURE__ */ new Error("Failed to normalize mail data"), sentMessageInfo);
+				try {
+					let attachments = parseAttachments(data.attachments);
+					if (data.icalEvent) {
+						const icalAttachment = parseIcalEvent(data.icalEvent);
+						attachments = attachments ? [...attachments, icalAttachment] : [icalAttachment];
+					}
+					const sdkResponse = await sendMail({
+						...data.mailchannels,
+						from: parseAddress(data.from),
+						replyTo: parseAddress(data.replyTo),
+						to: parseAddresses(data.to),
+						cc: parseAddresses(data.cc),
+						bcc: parseAddresses(data.bcc),
+						subject: data.subject || "",
+						text: data.text?.toString() || "",
+						html: data.html?.toString() || "",
+						headers: parseHeaders(data.headers),
+						attachments,
+						dkim: parseDkim(data.dkim)
+					});
+					sentMessageInfo.response = sdkResponse;
+					if (sdkResponse.error) {
+						callback(new Error(sdkResponse.error.message), sentMessageInfo);
+						return;
+					}
+					if ("results" in sdkResponse.data && sdkResponse.data.results?.[0]) {
+						const result = sdkResponse.data.results[0];
+						sentMessageInfo.messageId = result.messageId;
+						switch (result.status) {
+							case "sent":
+								sentMessageInfo.accepted = sentMessageInfo.envelope.to;
+								break;
+							case "failed": sentMessageInfo.rejected = sentMessageInfo.envelope.to;
+						}
+					}
+					callback(null, sentMessageInfo);
+				} catch (error) {
+					callback(error, sentMessageInfo);
+				}
+			});
+		}
+	};
+};
+export { mailchannelsTransport };

package/dist/simulator/index.d.mts

@@ -0,0 +1,20 @@
+declare const createSimulator: (options?: {
+  host?: string;
+  port?: number;
+  silent?: boolean;
+}) => {
+  server: import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
+  state: {
+    emailApi: {
+      accounts: Map<any, any>;
+      apiKeyScopes: Map<any, any>;
+    };
+  };
+  readonly url: string | null;
+  close(): Promise<void>;
+  listen(listenOptions?: {
+    host?: string;
+    port?: number;
+  }): Promise<string>;
+};
+export { createSimulator };

package/dist/simulator/index.mjs

@@ -0,0 +1,2 @@
+import { createSimulator } from "../_chunks/simulator.mjs";
+export { createSimulator };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mailchannels-sdk",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "description": "Node.js SDK to integrate MailChannels Email API into your JavaScript or TypeScript server-side applications.",
   "type": "module",
   "license": "MIT",
@@ -25,6 +25,14 @@
     ".": {
       "types": "./dist/mailchannels.d.mts",
       "default": "./dist/mailchannels.mjs"
+    },
+    "./simulator": {
+      "types": "./dist/simulator/index.d.mts",
+      "default": "./dist/simulator/index.mjs"
+    },
+    "./nodemailer": {
+      "types": "./dist/plugins/nodemailer/index.d.mts",
+      "default": "./dist/plugins/nodemailer/index.mjs"
     }
   },
   "types": "./dist/mailchannels.d.mts",
@@ -37,22 +45,25 @@
     ".agents/skills/mailchannels-js"
   ],
   "dependencies": {
+    "citty": "^0.2.2",
     "mime": "^4.1.0",
     "ofetch": "^2.0.0-alpha.3"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/markdown-it": "^14.1.2",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
+    "@types/nodemailer": "^8.0.1",
     "@vitest/coverage-v8": "^4.1.10",
     "changelogen": "^0.6.2",
+    "nodemailer": "^9.0.5",
     "obuild": "^0.4.38",
-    "oxlint": "^1.76.0",
+    "oxlint": "^1.78.0",
     "scule": "^1.3.0",
     "typescript": "^6.0.3",
-    "vitepress": "^2.0.0-alpha.18",
+    "vitepress": "^2.0.0-alpha.19",
     "vitepress-plugin-group-icons": "^1.7.6",
-    "vitepress-plugin-llms": "^1.13.4",
+    "vitepress-plugin-llms": "^1.13.5",
     "vitest": "^4.1.10"
   },
   "engines": {
@@ -62,7 +73,8 @@
     "build": "obuild",
     "parity:fixtures": "node scripts/generate-parity-fixtures.ts",
     "release": "pnpm lint && pnpm test && pnpm build && changelogen --bump",
-    "simulate": "node src/cli/index.ts simulate",
+    "cli": "pnpx jiti src/cli/index.ts",
+    "simulate": "pnpx jiti src/cli/index.ts simulate",
     "lint": "oxlint",
     "lint:fix": "oxlint --fix",
     "test": "vitest run --reporter=verbose --coverage",

package/dist/cli/index.d.mts

@@ -1 +0,0 @@
-export {}