Cursor Agentandnsrb
23ce72fec2
Expose broader nodemailer transport options, require a separate from address, and support optional cc/bcc plus reply-to and custom headers. Co-authored-by: Nasyarobby Putra <nasyarobby@gmail.com>
434 lines
13 KiB
JavaScript
434 lines
13 KiB
JavaScript
import nodemailer from "nodemailer";
|
|
|
|
/**
|
|
* @param {unknown} value
|
|
* @param {string} label
|
|
* @returns {string | undefined}
|
|
*/
|
|
function normalizeRecipients(value, label) {
|
|
if (value == null || value === "") return undefined;
|
|
if (typeof value === "string") return value;
|
|
if (Array.isArray(value)) {
|
|
const items = value.filter((item) => typeof item === "string" && item.length > 0);
|
|
if (items.length === 0) return undefined;
|
|
if (items.length !== value.length) {
|
|
throw new Error(`${label} must be a string or array of non-empty strings`);
|
|
}
|
|
return items.join(", ");
|
|
}
|
|
throw new Error(`${label} must be a string or array of strings`);
|
|
}
|
|
|
|
/**
|
|
* @param {Record<string, unknown>} config
|
|
* @param {string | null} password
|
|
*/
|
|
function buildTransportOptions(config, password) {
|
|
/** @type {import("nodemailer").TransportOptions} */
|
|
const transport = {};
|
|
|
|
if (typeof config.service === "string" && config.service.length > 0) {
|
|
transport.service = config.service;
|
|
}
|
|
if (typeof config.url === "string" && config.url.length > 0) {
|
|
transport.url = config.url;
|
|
}
|
|
if (typeof config.host === "string" && config.host.length > 0) {
|
|
transport.host = config.host;
|
|
}
|
|
if (config.port != null && config.port !== "") {
|
|
transport.port = Number(config.port);
|
|
}
|
|
if (config.secure === true) transport.secure = true;
|
|
if (config.requireTLS === true) transport.requireTLS = true;
|
|
if (config.ignoreTLS === true) transport.ignoreTLS = true;
|
|
if (typeof config.name === "string" && config.name.length > 0) {
|
|
transport.name = config.name;
|
|
}
|
|
if (config.connectionTimeout != null && config.connectionTimeout !== "") {
|
|
transport.connectionTimeout = Number(config.connectionTimeout);
|
|
}
|
|
if (config.greetingTimeout != null && config.greetingTimeout !== "") {
|
|
transport.greetingTimeout = Number(config.greetingTimeout);
|
|
}
|
|
if (config.socketTimeout != null && config.socketTimeout !== "") {
|
|
transport.socketTimeout = Number(config.socketTimeout);
|
|
}
|
|
if (typeof config.authMethod === "string" && config.authMethod.length > 0) {
|
|
transport.authMethod = config.authMethod;
|
|
}
|
|
if (config.tls != null && typeof config.tls === "object" && !Array.isArray(config.tls)) {
|
|
transport.tls = config.tls;
|
|
}
|
|
if (config.pool === true) {
|
|
transport.pool = true;
|
|
if (config.maxConnections != null && config.maxConnections !== "") {
|
|
transport.maxConnections = Number(config.maxConnections);
|
|
}
|
|
if (config.maxMessages != null && config.maxMessages !== "") {
|
|
transport.maxMessages = Number(config.maxMessages);
|
|
}
|
|
if (config.rateDelta != null && config.rateDelta !== "") {
|
|
transport.rateDelta = Number(config.rateDelta);
|
|
}
|
|
if (config.rateLimit != null && config.rateLimit !== "") {
|
|
transport.rateLimit = Number(config.rateLimit);
|
|
}
|
|
}
|
|
|
|
const user = config.user;
|
|
if (typeof user === "string" && user.length > 0) {
|
|
/** @type {Record<string, unknown>} */
|
|
const auth = { user };
|
|
if (typeof password === "string" && password.length > 0) {
|
|
auth.pass = password;
|
|
}
|
|
if (typeof config.authType === "string" && config.authType.length > 0) {
|
|
auth.type = config.authType;
|
|
}
|
|
if (typeof config.authMethod === "string" && config.authMethod.length > 0) {
|
|
auth.method = config.authMethod;
|
|
}
|
|
transport.auth = auth;
|
|
}
|
|
|
|
return transport;
|
|
}
|
|
|
|
/**
|
|
* @param {Record<string, unknown>} config
|
|
*/
|
|
function assertTransportConfig(config) {
|
|
const hasEndpoint =
|
|
(typeof config.service === "string" && config.service.length > 0) ||
|
|
(typeof config.host === "string" && config.host.length > 0) ||
|
|
(typeof config.url === "string" && config.url.length > 0) ||
|
|
(typeof config.urlSecret === "string" && config.urlSecret.length > 0);
|
|
|
|
if (!hasEndpoint) {
|
|
throw new Error("config.service, config.host, config.url, or config.urlSecret is required");
|
|
}
|
|
|
|
const hasUrl = typeof config.url === "string" && config.url.length > 0;
|
|
const hasUrlSecret = typeof config.urlSecret === "string" && config.urlSecret.length > 0;
|
|
const hasUser = typeof config.user === "string" && config.user.length > 0;
|
|
const hasPasswordSecret =
|
|
typeof config.passwordSecret === "string" && config.passwordSecret.length > 0;
|
|
|
|
if (!hasUrl && !hasUrlSecret && !hasUser) {
|
|
throw new Error("config.user is required unless config.url or config.urlSecret is set");
|
|
}
|
|
if (!hasUrl && !hasUrlSecret && !hasPasswordSecret) {
|
|
throw new Error("config.passwordSecret is required unless config.url or config.urlSecret is set");
|
|
}
|
|
}
|
|
|
|
async function sendEmail(ctx) {
|
|
const config = ctx.config ?? {};
|
|
assertTransportConfig(config);
|
|
|
|
const fromConfig =
|
|
typeof config.from === "string" && config.from.length > 0 ? config.from : undefined;
|
|
const fromData =
|
|
typeof ctx.data?.from === "string" && ctx.data.from.length > 0 ? ctx.data.from : undefined;
|
|
const from = fromData ?? fromConfig;
|
|
if (!from) {
|
|
throw new Error("data.from or config.from is required (sender email address)");
|
|
}
|
|
|
|
const to = normalizeRecipients(ctx.data?.to, "data.to");
|
|
if (!to) {
|
|
throw new Error("data.to is required");
|
|
}
|
|
|
|
const subject = ctx.data?.subject;
|
|
if (typeof subject !== "string" || subject.length === 0) {
|
|
throw new Error("data.subject is required");
|
|
}
|
|
|
|
const text = ctx.data?.text ?? ctx.data?.body ?? ctx.data?.message;
|
|
if (typeof text !== "string" || text.length === 0) {
|
|
throw new Error("data.text is required (plain-text body)");
|
|
}
|
|
|
|
const cc = normalizeRecipients(ctx.data?.cc, "data.cc");
|
|
const bcc = normalizeRecipients(ctx.data?.bcc, "data.bcc");
|
|
const replyTo =
|
|
normalizeRecipients(ctx.data?.replyTo ?? config.replyTo, "replyTo");
|
|
|
|
let url = typeof config.url === "string" && config.url.length > 0 ? config.url : undefined;
|
|
if (!url && typeof config.urlSecret === "string" && config.urlSecret.length > 0) {
|
|
url = $secrets.reveal(await $secrets.get(config.urlSecret));
|
|
}
|
|
|
|
let password = null;
|
|
if (typeof config.passwordSecret === "string" && config.passwordSecret.length > 0) {
|
|
password = $secrets.reveal(await $secrets.get(config.passwordSecret));
|
|
}
|
|
|
|
const transportConfig = url ? { ...config, url } : config;
|
|
const transporter = nodemailer.createTransport(buildTransportOptions(transportConfig, password));
|
|
|
|
/** @type {import("nodemailer").SendMailOptions} */
|
|
const mail = {
|
|
from,
|
|
to,
|
|
subject,
|
|
text,
|
|
};
|
|
if (cc) mail.cc = cc;
|
|
if (bcc) mail.bcc = bcc;
|
|
if (replyTo) mail.replyTo = replyTo;
|
|
|
|
if (typeof config.priority === "string" && config.priority.length > 0) {
|
|
mail.priority = config.priority;
|
|
} else if (typeof ctx.data?.priority === "string" && ctx.data.priority.length > 0) {
|
|
mail.priority = ctx.data.priority;
|
|
}
|
|
|
|
if (ctx.data?.headers != null && typeof ctx.data.headers === "object" && !Array.isArray(ctx.data.headers)) {
|
|
mail.headers = ctx.data.headers;
|
|
} else if (config.headers != null && typeof config.headers === "object" && !Array.isArray(config.headers)) {
|
|
mail.headers = config.headers;
|
|
}
|
|
|
|
log.info(
|
|
{
|
|
service: config.service,
|
|
host: config.host,
|
|
port: config.port,
|
|
secure: config.secure === true,
|
|
from,
|
|
to,
|
|
cc: cc ?? null,
|
|
bcc: bcc ? "[redacted]" : null,
|
|
subjectLength: subject.length,
|
|
textLength: text.length,
|
|
},
|
|
"send-email: sending plain-text message",
|
|
);
|
|
|
|
const info = await transporter.sendMail(mail);
|
|
|
|
log.info({ messageId: info.messageId }, "send-email: message sent");
|
|
|
|
return {
|
|
sent: true,
|
|
messageId: info.messageId ?? null,
|
|
from,
|
|
to,
|
|
cc: cc ?? null,
|
|
bcc: bcc ?? null,
|
|
subject,
|
|
};
|
|
}
|
|
|
|
sendEmail.meta = {
|
|
description: "Send a plain-text email via SMTP (nodemailer)",
|
|
config: {
|
|
service: {
|
|
type: "string",
|
|
required: false,
|
|
description:
|
|
"Well-known provider shortcut (e.g. gmail, outlook365, sendgrid). Alternative to host.",
|
|
},
|
|
host: {
|
|
type: "string",
|
|
required: false,
|
|
description: "SMTP server hostname (e.g. smtp.gmail.com)",
|
|
},
|
|
port: {
|
|
type: "number",
|
|
default: 587,
|
|
description: "SMTP port (587 for STARTTLS, 465 for SSL)",
|
|
},
|
|
secure: {
|
|
type: "boolean",
|
|
default: false,
|
|
description: "Use TLS on connect (true for port 465)",
|
|
},
|
|
requireTLS: {
|
|
type: "boolean",
|
|
required: false,
|
|
description: "Require STARTTLS upgrade",
|
|
},
|
|
ignoreTLS: {
|
|
type: "boolean",
|
|
required: false,
|
|
description: "Disable STARTTLS even if the server supports it",
|
|
},
|
|
name: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Client EHLO hostname",
|
|
},
|
|
user: {
|
|
type: "string",
|
|
required: false,
|
|
description: "SMTP auth username (separate from the visible From address)",
|
|
},
|
|
from: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Default sender email address (overridden by data.from)",
|
|
},
|
|
replyTo: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Default Reply-To address (overridden by data.replyTo)",
|
|
},
|
|
passwordSecret: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Named secret holding the SMTP password or app password",
|
|
},
|
|
url: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Full SMTP connection URL (smtp:// or smtps://); prefer urlSecret in production",
|
|
},
|
|
urlSecret: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Named secret holding a full SMTP connection URL",
|
|
},
|
|
authType: {
|
|
type: "string",
|
|
required: false,
|
|
description: "SMTP auth type (e.g. LOGIN, OAUTH2)",
|
|
},
|
|
authMethod: {
|
|
type: "string",
|
|
required: false,
|
|
description: "SMTP auth method override (e.g. LOGIN, PLAIN, CRAM-MD5)",
|
|
},
|
|
tls: {
|
|
type: "object",
|
|
required: false,
|
|
description: "TLS options (e.g. rejectUnauthorized, minVersion, ciphers)",
|
|
},
|
|
connectionTimeout: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Socket connection timeout in milliseconds",
|
|
},
|
|
greetingTimeout: {
|
|
type: "number",
|
|
required: false,
|
|
description: "SMTP greeting timeout in milliseconds",
|
|
},
|
|
socketTimeout: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Socket inactivity timeout in milliseconds",
|
|
},
|
|
pool: {
|
|
type: "boolean",
|
|
required: false,
|
|
description: "Reuse SMTP connections",
|
|
},
|
|
maxConnections: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Max pooled connections when pool is enabled",
|
|
},
|
|
maxMessages: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Max messages per pooled connection",
|
|
},
|
|
rateDelta: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Rate limit window in milliseconds when pool is enabled",
|
|
},
|
|
rateLimit: {
|
|
type: "number",
|
|
required: false,
|
|
description: "Max messages per rateDelta when pool is enabled",
|
|
},
|
|
priority: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Default message priority: high, normal, or low",
|
|
},
|
|
headers: {
|
|
type: "object",
|
|
required: false,
|
|
description: "Default custom headers object",
|
|
},
|
|
},
|
|
input: {
|
|
from: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Sender email address (overrides config.from)",
|
|
},
|
|
to: {
|
|
type: "string",
|
|
required: true,
|
|
description: "Recipient(s); string or array of strings",
|
|
},
|
|
cc: {
|
|
type: "string",
|
|
required: false,
|
|
description: "CC recipient(s); string or array of strings",
|
|
},
|
|
bcc: {
|
|
type: "string",
|
|
required: false,
|
|
description: "BCC recipient(s); string or array of strings",
|
|
},
|
|
replyTo: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Reply-To address (overrides config.replyTo)",
|
|
},
|
|
subject: { type: "string", required: true, description: "Email subject" },
|
|
text: {
|
|
type: "string",
|
|
required: true,
|
|
description: "Plain-text body (aliases: body, message)",
|
|
},
|
|
priority: {
|
|
type: "string",
|
|
required: false,
|
|
description: "Message priority: high, normal, or low",
|
|
},
|
|
headers: {
|
|
type: "object",
|
|
required: false,
|
|
description: "Per-message custom headers",
|
|
},
|
|
},
|
|
output: {
|
|
sent: { type: "boolean", description: "Whether the message was sent" },
|
|
messageId: { type: "string", description: "SMTP message id when available" },
|
|
from: { type: "string" },
|
|
to: { type: "string" },
|
|
cc: { type: "string" },
|
|
bcc: { type: "string" },
|
|
subject: { type: "string" },
|
|
},
|
|
example: {
|
|
data: {
|
|
from: "notifications@example.com",
|
|
to: ["recipient@example.com", "other@example.com"],
|
|
cc: "manager@example.com",
|
|
bcc: "audit@example.com",
|
|
subject: "Hello from scrunner",
|
|
text: "This is a plain-text test message.",
|
|
},
|
|
config: {
|
|
host: "smtp.gmail.com",
|
|
port: 587,
|
|
secure: false,
|
|
user: "smtp-login@gmail.com",
|
|
from: "notifications@example.com",
|
|
passwordSecret: "gmail_app_password",
|
|
},
|
|
},
|
|
};
|
|
|
|
export default sendEmail;
|