@nixxie-cms/email 1.0.1

package/dist/nixxie-cms-email.esm.js

@@ -0,0 +1,983 @@
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import fs from 'fs';
+import path from 'path';
+import nodemailer from 'nodemailer';
+
+// Higher number = processed first
+const PRIORITY_RANK = {
+  high: 2,
+  normal: 1,
+  low: 0
+};
+class EmailQueue {
+  constructor(config, handler) {
+    var _config$enabled, _config$concurrency, _config$retries, _config$retryDelay, _config$maxAge;
+    _defineProperty(this, "jobs", []);
+    _defineProperty(this, "processing", new Set());
+    _defineProperty(this, "timer", null);
+    _defineProperty(this, "running", false);
+    _defineProperty(this, "completedCount", 0);
+    this.config = {
+      enabled: (_config$enabled = config.enabled) !== null && _config$enabled !== void 0 ? _config$enabled : true,
+      concurrency: (_config$concurrency = config.concurrency) !== null && _config$concurrency !== void 0 ? _config$concurrency : 5,
+      retries: (_config$retries = config.retries) !== null && _config$retries !== void 0 ? _config$retries : 3,
+      retryDelay: (_config$retryDelay = config.retryDelay) !== null && _config$retryDelay !== void 0 ? _config$retryDelay : 5000,
+      maxAge: (_config$maxAge = config.maxAge) !== null && _config$maxAge !== void 0 ? _config$maxAge : 86400000
+    };
+    this.handler = handler;
+  }
+  enqueue(job) {
+    const queued = {
+      ...job,
+      id: `job-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+      status: 'pending',
+      attempts: 0,
+      createdAt: new Date()
+    };
+    this.jobs.push(queued);
+    this.scheduleFlush();
+    return queued;
+  }
+  start() {
+    this.running = true;
+    this.scheduleFlush();
+  }
+  stop() {
+    this.running = false;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  getStats() {
+    const now = Date.now();
+    return {
+      pending: this.jobs.filter(j => j.status === 'pending' && (!j.sendAt || j.sendAt.getTime() <= now)).length,
+      processing: this.processing.size,
+      failed: this.jobs.filter(j => j.status === 'failed').length,
+      completed: this.completedCount
+    };
+  }
+  async flush() {
+    const now = Date.now();
+
+    // Expire old jobs. maxAge <= 0 means "never discard".
+    this.jobs = this.jobs.filter(j => {
+      if (j.status === 'completed') return false;
+      if (this.config.maxAge > 0 && now - j.createdAt.getTime() > this.config.maxAge) return false;
+      return true;
+    });
+    const available = this.jobs.filter(j => {
+      if (j.status !== 'pending') return false;
+      if (this.processing.has(j.id)) return false;
+      if (j.sendAt && j.sendAt.getTime() > now) return false;
+      return true;
+    })
+    // Highest priority first, then oldest first (FIFO within a priority)
+    .sort((a, b) => {
+      const byPriority = PRIORITY_RANK[b.priority] - PRIORITY_RANK[a.priority];
+      if (byPriority !== 0) return byPriority;
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    const slots = this.config.concurrency - this.processing.size;
+    const toProcess = available.slice(0, slots);
+    await Promise.all(toProcess.map(job => this.processJob(job)));
+  }
+  async processJob(job) {
+    this.processing.add(job.id);
+    job.status = 'processing';
+    job.attempts++;
+    try {
+      await this.handler(job);
+      job.status = 'completed';
+      this.completedCount++;
+    } catch (err) {
+      job.lastError = err instanceof Error ? err.message : String(err);
+
+      // `retries` is the number of retries after the initial attempt, so total attempts =
+      // 1 + retries. `attempts` is pre-incremented, hence `<=`.
+      if (job.attempts <= this.config.retries) {
+        job.status = 'pending';
+        // Exponential backoff
+        job.sendAt = new Date(Date.now() + this.config.retryDelay * Math.pow(2, job.attempts - 1));
+      } else {
+        job.status = 'failed';
+      }
+    } finally {
+      this.processing.delete(job.id);
+    }
+  }
+  scheduleFlush() {
+    if (!this.running || this.timer) return;
+    this.timer = setTimeout(async () => {
+      this.timer = null;
+      await this.flush();
+      if (this.jobs.some(j => j.status === 'pending')) {
+        this.scheduleFlush();
+      }
+    }, 100);
+  }
+}
+
+let handlebars;
+function getHandlebars() {
+  if (!handlebars) {
+    try {
+      handlebars = require('handlebars');
+    } catch {
+      throw new Error('Handlebars is not installed. Run: npm install handlebars');
+    }
+  }
+  return handlebars;
+}
+class HandlebarsEngine {
+  constructor(config) {
+    _defineProperty(this, "cache", new Map());
+    this.hbs = getHandlebars().create();
+    this.config = config;
+    this.registerHelpers();
+    this.registerPartials();
+  }
+  registerHelpers() {
+    var _this$config$engineOp;
+    // Handlebars engine options are a flat shape: `{ noEscape?, helpers? }` (see EmailTemplatesConfig).
+    const helpers = (_this$config$engineOp = this.config.engineOptions) === null || _this$config$engineOp === void 0 ? void 0 : _this$config$engineOp.helpers;
+    if (!helpers) return;
+    for (const [name, fn] of Object.entries(helpers)) {
+      this.hbs.registerHelper(name, fn);
+    }
+  }
+  compileOptions() {
+    var _this$config$engineOp2;
+    return (_this$config$engineOp2 = this.config.engineOptions) !== null && _this$config$engineOp2 !== void 0 && _this$config$engineOp2.noEscape ? {
+      noEscape: true
+    } : undefined;
+  }
+  registerPartials() {
+    // `partials` is a boolean flag (default: enabled). Load from `<dir>/partials` when on.
+    if (this.config.partials === false || !this.config.dir) return;
+    const partialsDir = path.join(this.config.dir, 'partials');
+    if (!fs.existsSync(partialsDir)) return;
+    const files = fs.readdirSync(partialsDir);
+    for (const file of files) {
+      if (!/\.(hbs|handlebars)$/.test(file)) continue;
+      const name = path.basename(file, path.extname(file));
+      const content = fs.readFileSync(path.join(partialsDir, file), 'utf-8');
+      this.hbs.registerPartial(name, content);
+    }
+  }
+  async render(templateName, data) {
+    const compiled = this.getCompiled(templateName);
+    const layout = this.config.layouts ? this.resolveLayout(templateName) : null;
+    let body = compiled(data);
+    if (layout) {
+      const layoutTemplate = this.getCompiledLayout(layout);
+      body = layoutTemplate({
+        ...data,
+        body
+      });
+    }
+    return body;
+  }
+  getCompiled(templateName) {
+    const cacheKey = `template:${templateName}`;
+    if (this.config.cache !== false && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const filePath = this.resolveTemplatePath(templateName);
+    const source = fs.readFileSync(filePath, 'utf-8');
+    const compiled = this.hbs.compile(source, this.compileOptions());
+    if (this.config.cache !== false) {
+      this.cache.set(cacheKey, compiled);
+    }
+    return compiled;
+  }
+  getCompiledLayout(layoutPath) {
+    const cacheKey = `layout:${layoutPath}`;
+    if (this.config.cache !== false && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const source = fs.readFileSync(layoutPath, 'utf-8');
+    const compiled = this.hbs.compile(source, this.compileOptions());
+    if (this.config.cache !== false) {
+      this.cache.set(cacheKey, compiled);
+    }
+    return compiled;
+  }
+  resolveTemplatePath(templateName) {
+    if (!this.config.dir) {
+      throw new Error('templates.dir must be set to use template rendering');
+    }
+    const candidates = [path.join(this.config.dir, `${templateName}.hbs`), path.join(this.config.dir, `${templateName}.handlebars`), path.join(this.config.dir, templateName, 'html.hbs'), path.join(this.config.dir, templateName, 'html.handlebars')];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) return candidate;
+    }
+    throw new Error(`Handlebars template not found: ${templateName} (searched in ${this.config.dir})`);
+  }
+  resolveLayout(templateName) {
+    if (!this.config.layouts) return null;
+
+    // Per-template layout override: templates/<name>/layout.hbs
+    if (this.config.dir) {
+      const perTemplate = path.join(this.config.dir, templateName, 'layout.hbs');
+      if (fs.existsSync(perTemplate)) return perTemplate;
+    }
+
+    // Default layout: templates/layouts/default.hbs
+    const defaultLayout = path.join(this.config.dir, 'layouts', 'default.hbs');
+    if (fs.existsSync(defaultLayout)) return defaultLayout;
+    return null;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+let pugModule;
+function getPug() {
+  if (!pugModule) {
+    try {
+      pugModule = require('pug');
+    } catch {
+      throw new Error('Pug is not installed. Run: npm install pug');
+    }
+  }
+  return pugModule;
+}
+class PugEngine {
+  constructor(config) {
+    _defineProperty(this, "cache", new Map());
+    this.config = config;
+  }
+  async render(templateName, data) {
+    const p = getPug();
+    const compiled = this.getCompiled(templateName, p);
+    const layout = this.config.layouts ? this.resolveLayout(templateName) : null;
+    const renderData = {
+      ...data
+    };
+    if (layout) {
+      renderData['layout'] = layout;
+    }
+    return compiled(renderData);
+  }
+  getCompiled(templateName, p) {
+    var _this$config$engineOp, _this$config$engineOp2;
+    const cacheKey = `template:${templateName}`;
+    if (this.config.cache !== false && this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+    const filePath = this.resolveTemplatePath(templateName);
+    const engineOptions = (_this$config$engineOp = (_this$config$engineOp2 = this.config.engineOptions) === null || _this$config$engineOp2 === void 0 ? void 0 : _this$config$engineOp2.pug) !== null && _this$config$engineOp !== void 0 ? _this$config$engineOp : {};
+    const compiled = p.compileFile(filePath, {
+      ...engineOptions,
+      filename: filePath,
+      cache: false
+    });
+    if (this.config.cache !== false) {
+      this.cache.set(cacheKey, compiled);
+    }
+    return compiled;
+  }
+  resolveTemplatePath(templateName) {
+    if (!this.config.dir) {
+      throw new Error('templates.dir must be set to use template rendering');
+    }
+    const candidates = [path.join(this.config.dir, `${templateName}.pug`), path.join(this.config.dir, `${templateName}.jade`), path.join(this.config.dir, templateName, 'html.pug'), path.join(this.config.dir, templateName, 'index.pug')];
+    for (const candidate of candidates) {
+      if (fs.existsSync(candidate)) return candidate;
+    }
+    throw new Error(`Pug template not found: ${templateName} (searched in ${this.config.dir})`);
+  }
+  resolveLayout(templateName) {
+    if (!this.config.layouts) return null;
+    if (this.config.dir) {
+      const perTemplate = path.join(this.config.dir, templateName, 'layout.pug');
+      if (fs.existsSync(perTemplate)) return perTemplate;
+    }
+
+    // Default layout: templates/layouts/default.pug
+    const defaultLayout = path.join(this.config.dir, 'layouts', 'default.pug');
+    if (fs.existsSync(defaultLayout)) return defaultLayout;
+    return null;
+  }
+  clearCache() {
+    this.cache.clear();
+  }
+}
+
+class TemplateManager {
+  constructor(config) {
+    var _config$engine;
+    this.config = config;
+    const engine = (_config$engine = config.engine) !== null && _config$engine !== void 0 ? _config$engine : 'handlebars';
+    if (engine === 'handlebars' || engine === 'auto') {
+      this.handlebars = new HandlebarsEngine(config);
+    }
+    if (engine === 'pug' || engine === 'auto') {
+      this.pug = new PugEngine(config);
+    }
+  }
+  async render(templateName, data) {
+    const engine = this.detectEngine(templateName);
+    switch (engine) {
+      case 'handlebars':
+        return this.renderWithHandlebars(templateName, data);
+      case 'pug':
+        return this.renderWithPug(templateName, data);
+      default:
+        throw new Error(`No template engine configured for template: ${templateName}`);
+    }
+  }
+  detectEngine(templateName) {
+    var _this$config$engine;
+    const configuredEngine = (_this$config$engine = this.config.engine) !== null && _this$config$engine !== void 0 ? _this$config$engine : 'handlebars';
+    if (configuredEngine === 'auto' || configuredEngine === 'handlebars') {
+      if (this.config.dir) {
+        const hbsCandidates = [path.join(this.config.dir, `${templateName}.hbs`), path.join(this.config.dir, `${templateName}.handlebars`), path.join(this.config.dir, templateName, 'html.hbs'), path.join(this.config.dir, templateName, 'html.handlebars')];
+        if (hbsCandidates.some(p => fs.existsSync(p))) return 'handlebars';
+      }
+    }
+    if (configuredEngine === 'auto' || configuredEngine === 'pug') {
+      if (this.config.dir) {
+        const pugCandidates = [path.join(this.config.dir, `${templateName}.pug`), path.join(this.config.dir, `${templateName}.jade`), path.join(this.config.dir, templateName, 'html.pug'), path.join(this.config.dir, templateName, 'index.pug')];
+        if (pugCandidates.some(p => fs.existsSync(p))) return 'pug';
+      }
+    }
+    if (configuredEngine !== 'auto') return configuredEngine;
+    return null;
+  }
+  async renderWithHandlebars(templateName, data) {
+    if (!this.handlebars) {
+      this.handlebars = new HandlebarsEngine(this.config);
+    }
+    const html = await this.handlebars.render(templateName, data);
+    const text = await this.renderTextVersion(templateName, data, 'handlebars');
+    const subject = await this.renderSubject(templateName, data, 'handlebars');
+    return {
+      html,
+      text,
+      subject
+    };
+  }
+  async renderWithPug(templateName, data) {
+    if (!this.pug) {
+      this.pug = new PugEngine(this.config);
+    }
+    const html = await this.pug.render(templateName, data);
+    const text = await this.renderTextVersion(templateName, data, 'pug');
+    const subject = await this.renderSubject(templateName, data, 'pug');
+    return {
+      html,
+      text,
+      subject
+    };
+  }
+  async renderTextVersion(templateName, data, engine) {
+    if (!this.config.dir) return undefined;
+    const textPaths = engine === 'handlebars' ? [path.join(this.config.dir, templateName, 'text.hbs'), path.join(this.config.dir, templateName, 'text.handlebars'), path.join(this.config.dir, `${templateName}.text.hbs`)] : [path.join(this.config.dir, templateName, 'text.pug'), path.join(this.config.dir, `${templateName}.text.pug`)];
+    const textFile = textPaths.find(p => fs.existsSync(p));
+    if (!textFile) return undefined;
+
+    // Render a plain-text variant using the same engine but without layout
+    const textConfig = {
+      ...this.config,
+      layouts: undefined
+    };
+    try {
+      if (engine === 'handlebars') {
+        const eng = new HandlebarsEngine(textConfig);
+        return await eng.render(path.relative(this.config.dir, textFile).replace(/\\/g, '/').replace(/\.(hbs|handlebars)$/, ''), data);
+      } else {
+        const eng = new PugEngine(textConfig);
+        return await eng.render(path.relative(this.config.dir, textFile).replace(/\\/g, '/').replace(/\.(pug|jade)$/, ''), data);
+      }
+    } catch {
+      // Fall back to reading the file as plain template
+      return fs.readFileSync(textFile, 'utf-8');
+    }
+  }
+  async renderSubject(templateName, data, engine) {
+    if (!this.config.dir) return undefined;
+    const subjectPaths = engine === 'handlebars' ? [path.join(this.config.dir, templateName, 'subject.hbs'), path.join(this.config.dir, templateName, 'subject.handlebars')] : [path.join(this.config.dir, templateName, 'subject.pug')];
+    const subjectFile = subjectPaths.find(p => fs.existsSync(p));
+    if (!subjectFile) return undefined;
+    const subjectConfig = {
+      ...this.config,
+      layouts: undefined
+    };
+    try {
+      if (engine === 'handlebars') {
+        const eng = new HandlebarsEngine(subjectConfig);
+        const relative = path.relative(this.config.dir, subjectFile).replace(/\\/g, '/').replace(/\.(hbs|handlebars)$/, '');
+        return (await eng.render(relative, data)).trim();
+      } else {
+        const eng = new PugEngine(subjectConfig);
+        const relative = path.relative(this.config.dir, subjectFile).replace(/\\/g, '/').replace(/\.(pug|jade)$/, '');
+        return (await eng.render(relative, data)).trim();
+      }
+    } catch {
+      return undefined;
+    }
+  }
+  clearCache() {
+    var _this$handlebars, _this$pug;
+    (_this$handlebars = this.handlebars) === null || _this$handlebars === void 0 || _this$handlebars.clearCache();
+    (_this$pug = this.pug) === null || _this$pug === void 0 || _this$pug.clearCache();
+  }
+}
+
+let messageCounter = 0;
+class ConsoleTransport {
+  async send(message) {
+    var _message$cc, _message$bcc, _message$replyTo, _message$attachments;
+    const id = `console-${Date.now()}-${++messageCounter}`;
+    const separator = '─'.repeat(60);
+    console.log(`\n${separator}`);
+    console.log('📧  [Nixxie Email — Development Mode]');
+    console.log(separator);
+    console.log(`  From:     ${message.from}`);
+    console.log(`  To:       ${message.to.join(', ')}`);
+    if ((_message$cc = message.cc) !== null && _message$cc !== void 0 && _message$cc.length) console.log(`  CC:       ${message.cc.join(', ')}`);
+    if ((_message$bcc = message.bcc) !== null && _message$bcc !== void 0 && _message$bcc.length) console.log(`  BCC:      ${message.bcc.join(', ')}`);
+    if ((_message$replyTo = message.replyTo) !== null && _message$replyTo !== void 0 && _message$replyTo.length) console.log(`  Reply-To: ${message.replyTo.join(', ')}`);
+    console.log(`  Subject:  ${message.subject}`);
+    console.log(`  ID:       ${id}`);
+    if ((_message$attachments = message.attachments) !== null && _message$attachments !== void 0 && _message$attachments.length) {
+      console.log(`  Attachments:`);
+      for (const a of message.attachments) {
+        var _ref, _a$filename;
+        console.log(`    • ${(_ref = (_a$filename = a.filename) !== null && _a$filename !== void 0 ? _a$filename : a.path) !== null && _ref !== void 0 ? _ref : 'unnamed'}`);
+      }
+    }
+    if (message.text) {
+      console.log(`\n  Text body:\n  ${message.text.slice(0, 300).replace(/\n/g, '\n  ')}`);
+    }
+    if (message.html) {
+      const truncated = message.html.replace(/<[^>]+>/g, '').trim().slice(0, 200);
+      console.log(`\n  HTML preview:\n  ${truncated}…`);
+    }
+    console.log(`${separator}\n`);
+    return {
+      messageId: id,
+      accepted: message.to,
+      rejected: [],
+      response: 'logged'
+    };
+  }
+  async verify() {
+    return true;
+  }
+  async close() {
+    // nothing to close
+  }
+}
+
+class MailgunTransport {
+  constructor(config) {
+    const host = config.region === 'eu' ? 'smtp.eu.mailgun.org' : 'smtp.mailgun.org';
+    this.transporter = nodemailer.createTransport({
+      host,
+      port: 587,
+      secure: false,
+      auth: {
+        user: `postmaster@${config.domain}`,
+        pass: config.apiKey
+      }
+    });
+  }
+  async send(message) {
+    var _message$cc, _message$bcc, _message$replyTo, _ref, _ref2;
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: (_message$cc = message.cc) === null || _message$cc === void 0 ? void 0 : _message$cc.join(', '),
+      bcc: (_message$bcc = message.bcc) === null || _message$bcc === void 0 ? void 0 : _message$bcc.join(', '),
+      replyTo: (_message$replyTo = message.replyTo) === null || _message$replyTo === void 0 ? void 0 : _message$replyTo.join(', '),
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments,
+      headers: message.headers
+    });
+    return {
+      messageId: info.messageId,
+      accepted: (_ref = info.accepted) !== null && _ref !== void 0 ? _ref : message.to,
+      rejected: (_ref2 = info.rejected) !== null && _ref2 !== void 0 ? _ref2 : [],
+      response: info.response
+    };
+  }
+  async verify() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    this.transporter.close();
+  }
+}
+
+class ResendTransport {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+  }
+  async send(message) {
+    var _message$attachments;
+    const body = {
+      from: message.from,
+      to: message.to,
+      cc: message.cc,
+      bcc: message.bcc,
+      reply_to: message.replyTo,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      headers: message.headers,
+      attachments: (_message$attachments = message.attachments) === null || _message$attachments === void 0 ? void 0 : _message$attachments.map(a => ({
+        filename: a.filename,
+        // Resend expects attachment `content` as base64; encode raw string/Buffer content.
+        content: a.content == null ? undefined : Buffer.isBuffer(a.content) ? a.content.toString('base64') : Buffer.from(a.content, 'utf-8').toString('base64'),
+        path: a.path
+      }))
+    };
+    const response = await fetch(`${this.baseUrl}/emails`, {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+    const json = await response.json();
+    if (!response.ok) {
+      const err = json;
+      throw new Error(`Resend API error ${response.status}: ${err.message}`);
+    }
+    const data = json;
+    return {
+      messageId: data.id,
+      accepted: message.to,
+      rejected: [],
+      response: `${response.status} ${response.statusText}`
+    };
+  }
+  async verify() {
+    try {
+      const response = await fetch(`${this.baseUrl}/domains`, {
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    // No persistent connections to close
+  }
+}
+
+class SendGridTransport {
+  constructor(config) {
+    // SendGrid supports nodemailer via their SMTP relay
+    this.transporter = nodemailer.createTransport({
+      host: 'smtp.sendgrid.net',
+      port: 587,
+      secure: false,
+      auth: {
+        user: 'apikey',
+        pass: config.apiKey
+      }
+    });
+  }
+  async send(message) {
+    var _message$cc, _message$bcc, _message$replyTo, _ref, _ref2;
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: (_message$cc = message.cc) === null || _message$cc === void 0 ? void 0 : _message$cc.join(', '),
+      bcc: (_message$bcc = message.bcc) === null || _message$bcc === void 0 ? void 0 : _message$bcc.join(', '),
+      replyTo: (_message$replyTo = message.replyTo) === null || _message$replyTo === void 0 ? void 0 : _message$replyTo.join(', '),
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments,
+      headers: message.headers
+    });
+    return {
+      messageId: info.messageId,
+      accepted: (_ref = info.accepted) !== null && _ref !== void 0 ? _ref : message.to,
+      rejected: (_ref2 = info.rejected) !== null && _ref2 !== void 0 ? _ref2 : [],
+      response: info.response
+    };
+  }
+  async verify() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    this.transporter.close();
+  }
+}
+
+class SesTransport {
+  constructor(config) {
+    // Uses SES SMTP interface — credentials are SES SMTP credentials (different from IAM keys)
+    // See: https://docs.aws.amazon.com/ses/latest/dg/smtp-credentials.html
+    this.transporter = nodemailer.createTransport({
+      host: `email-smtp.${config.region}.amazonaws.com`,
+      port: 587,
+      secure: false,
+      auth: config.credentials ? {
+        user: config.credentials.accessKeyId,
+        pass: config.credentials.secretAccessKey
+      } : undefined,
+      tls: {
+        ciphers: 'SSLv3'
+      }
+    });
+  }
+  async send(message) {
+    var _message$cc, _message$bcc, _message$replyTo, _ref, _ref2;
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: (_message$cc = message.cc) === null || _message$cc === void 0 ? void 0 : _message$cc.join(', '),
+      bcc: (_message$bcc = message.bcc) === null || _message$bcc === void 0 ? void 0 : _message$bcc.join(', '),
+      replyTo: (_message$replyTo = message.replyTo) === null || _message$replyTo === void 0 ? void 0 : _message$replyTo.join(', '),
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: message.attachments,
+      headers: message.headers
+    });
+    return {
+      messageId: info.messageId,
+      accepted: (_ref = info.accepted) !== null && _ref !== void 0 ? _ref : message.to,
+      rejected: (_ref2 = info.rejected) !== null && _ref2 !== void 0 ? _ref2 : [],
+      response: info.response
+    };
+  }
+  async verify() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    this.transporter.close();
+  }
+}
+
+class SmtpTransport {
+  constructor(config) {
+    var _config$port, _config$secure, _config$connectionTim, _config$greetingTimeo, _config$socketTimeout, _config$pool, _config$maxConnection, _config$maxMessages;
+    this.transporter = nodemailer.createTransport({
+      host: config.host,
+      port: (_config$port = config.port) !== null && _config$port !== void 0 ? _config$port : 587,
+      secure: (_config$secure = config.secure) !== null && _config$secure !== void 0 ? _config$secure : config.port === 465,
+      auth: config.auth,
+      tls: config.tls,
+      connectionTimeout: (_config$connectionTim = config.connectionTimeout) !== null && _config$connectionTim !== void 0 ? _config$connectionTim : 5000,
+      greetingTimeout: (_config$greetingTimeo = config.greetingTimeout) !== null && _config$greetingTimeo !== void 0 ? _config$greetingTimeo : 5000,
+      socketTimeout: (_config$socketTimeout = config.socketTimeout) !== null && _config$socketTimeout !== void 0 ? _config$socketTimeout : 30000,
+      pool: (_config$pool = config.pool) !== null && _config$pool !== void 0 ? _config$pool : false,
+      maxConnections: (_config$maxConnection = config.maxConnections) !== null && _config$maxConnection !== void 0 ? _config$maxConnection : 5,
+      maxMessages: (_config$maxMessages = config.maxMessages) !== null && _config$maxMessages !== void 0 ? _config$maxMessages : 100
+    });
+  }
+  async send(message) {
+    var _message$cc, _message$bcc, _message$replyTo, _message$attachments, _ref, _ref2;
+    const info = await this.transporter.sendMail({
+      from: message.from,
+      to: message.to.join(', '),
+      cc: (_message$cc = message.cc) === null || _message$cc === void 0 ? void 0 : _message$cc.join(', '),
+      bcc: (_message$bcc = message.bcc) === null || _message$bcc === void 0 ? void 0 : _message$bcc.join(', '),
+      replyTo: (_message$replyTo = message.replyTo) === null || _message$replyTo === void 0 ? void 0 : _message$replyTo.join(', '),
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      attachments: (_message$attachments = message.attachments) === null || _message$attachments === void 0 ? void 0 : _message$attachments.map(a => ({
+        filename: a.filename,
+        content: a.content,
+        path: a.path,
+        href: a.href,
+        contentType: a.contentType,
+        encoding: a.encoding,
+        contentDisposition: a.contentDisposition,
+        cid: a.cid
+      })),
+      headers: message.headers
+    });
+    return {
+      messageId: info.messageId,
+      accepted: (_ref = info.accepted) !== null && _ref !== void 0 ? _ref : [],
+      rejected: (_ref2 = info.rejected) !== null && _ref2 !== void 0 ? _ref2 : [],
+      response: info.response
+    };
+  }
+  async verify() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async close() {
+    this.transporter.close();
+  }
+}
+
+function createTransport(config) {
+  switch (config.type) {
+    case 'smtp':
+      return new SmtpTransport(config);
+    case 'sendgrid':
+      return new SendGridTransport(config);
+    case 'mailgun':
+      return new MailgunTransport(config);
+    case 'ses':
+      return new SesTransport(config);
+    case 'resend':
+      return new ResendTransport(config);
+    case 'console':
+      return new ConsoleTransport();
+    default:
+      {
+        const exhaustiveCheck = config;
+        throw new Error(`Unknown email transport type: ${exhaustiveCheck.type}`);
+      }
+  }
+}
+
+function normalizeRecipients(recipients) {
+  const arr = Array.isArray(recipients) ? recipients : [recipients];
+  return arr.map(r => typeof r === 'string' ? r : r.name ? `"${r.name}" <${r.address}>` : r.address);
+}
+function extractAddress(recipient) {
+  if (typeof recipient === 'string') {
+    const match = recipient.match(/<(.+)>/);
+    return match ? match[1] : recipient;
+  }
+  return recipient.address;
+}
+class EmailService {
+  constructor(config) {
+    var _config$queue, _config$suppressionLi;
+    _defineProperty(this, "suppressionList", new Set());
+    this.config = config;
+
+    // In development mode, log emails to the console instead of delivering them for real.
+    this.transport = this.isDevMode() ? createTransport({
+      type: 'console'
+    }) : createTransport(config.transport);
+    if (config.templates) {
+      this.templateManager = new TemplateManager(config.templates);
+    }
+    if (((_config$queue = config.queue) === null || _config$queue === void 0 ? void 0 : _config$queue.enabled) !== false) {
+      var _config$queue2;
+      this.emailQueue = new EmailQueue((_config$queue2 = config.queue) !== null && _config$queue2 !== void 0 ? _config$queue2 : {}, async job => {
+        await this.sendImmediate(job.options);
+      });
+      this.emailQueue.start();
+    }
+    if ((_config$suppressionLi = config.suppressionList) !== null && _config$suppressionLi !== void 0 && _config$suppressionLi.length) {
+      for (const addr of config.suppressionList) {
+        this.suppressionList.add(addr.toLowerCase());
+      }
+    }
+  }
+  async send(options) {
+    return this.sendImmediate(options);
+  }
+  async bulk(recipients, options) {
+    const results = [];
+    for (const recipient of recipients) {
+      try {
+        const info = await this.sendImmediate({
+          ...options,
+          to: recipient
+        });
+        results.push(info);
+      } catch (err) {
+        try {
+          var _this$config$onFailed, _this$config;
+          await ((_this$config$onFailed = (_this$config = this.config).onFailed) === null || _this$config$onFailed === void 0 ? void 0 : _this$config$onFailed.call(_this$config, err instanceof Error ? err : new Error(String(err)), {
+            ...options,
+            to: recipient
+          }));
+        } catch {
+          // a failing onFailed callback must not abort the rest of the bulk send
+        }
+      }
+    }
+    return results;
+  }
+
+  /**
+   * Whether development mode is active. When a `development` config block is present, this defaults
+   * to `process.env.NODE_ENV !== 'production'` unless `development.enabled` is set explicitly.
+   * In dev mode emails are logged (and optionally written to `previewPath`) instead of being sent.
+   */
+  isDevMode() {
+    var _dev$enabled;
+    const dev = this.config.development;
+    if (!dev) return false;
+    return (_dev$enabled = dev.enabled) !== null && _dev$enabled !== void 0 ? _dev$enabled : process.env.NODE_ENV !== 'production';
+  }
+  async writePreview(dir, template, html) {
+    try {
+      await mkdir(dir, {
+        recursive: true
+      });
+      const safeName = (template !== null && template !== void 0 ? template : 'email').replace(/[^a-zA-Z0-9._-]/g, '_');
+      await writeFile(join(dir, `${safeName}-${Date.now()}.html`), html, 'utf-8');
+    } catch {
+      // Preview writing is best-effort and must never break sending.
+    }
+  }
+  queue(options) {
+    var _options$priority;
+    if (!this.emailQueue) {
+      throw new Error('Email queue is not enabled. Set queue.enabled = true in email config.');
+    }
+    const job = this.emailQueue.enqueue({
+      options,
+      sendAt: options.sendAt,
+      priority: (_options$priority = options.priority) !== null && _options$priority !== void 0 ? _options$priority : 'normal'
+    });
+    return job.id;
+  }
+  addToSuppressionList(address) {
+    this.suppressionList.add(address.toLowerCase());
+  }
+  removeFromSuppressionList(address) {
+    this.suppressionList.delete(address.toLowerCase());
+  }
+  isSuppressed(address) {
+    return this.suppressionList.has(address.toLowerCase());
+  }
+  getSuppressionList() {
+    return Array.from(this.suppressionList);
+  }
+  getQueueStats() {
+    if (!this.emailQueue) {
+      return {
+        pending: 0,
+        processing: 0,
+        failed: 0,
+        completed: 0
+      };
+    }
+    return this.emailQueue.getStats();
+  }
+  async flushQueue() {
+    if (this.emailQueue) {
+      await this.emailQueue.flush();
+    }
+  }
+  async close() {
+    var _this$emailQueue;
+    (_this$emailQueue = this.emailQueue) === null || _this$emailQueue === void 0 || _this$emailQueue.stop();
+    await this.transport.close();
+  }
+  async sendImmediate(options) {
+    var _this$config$developm, _options$from, _this$config$developm2;
+    const toAddresses = normalizeRecipients(Array.isArray(options.to) ? options.to : [options.to]);
+
+    // Apply dev override
+    let effectiveTo = toAddresses;
+    if ((_this$config$developm = this.config.development) !== null && _this$config$developm !== void 0 && _this$config$developm.enabled && this.config.development.toOverride) {
+      effectiveTo = normalizeRecipients(Array.isArray(this.config.development.toOverride) ? this.config.development.toOverride : [this.config.development.toOverride]);
+    }
+
+    // Suppression check
+    if (!options.skipSuppressionCheck) {
+      const suppressed = effectiveTo.filter(addr => {
+        const raw = extractAddress(addr);
+        return this.suppressionList.has(raw.toLowerCase());
+      });
+      if (suppressed.length) {
+        throw new Error(`Email suppressed for: ${suppressed.join(', ')}`);
+      }
+    }
+    let {
+      html,
+      text,
+      subject
+    } = options;
+
+    // Render template
+    if (options.template && this.templateManager) {
+      var _options$data;
+      const rendered = await this.templateManager.render(options.template, (_options$data = options.data) !== null && _options$data !== void 0 ? _options$data : {});
+      html = html !== null && html !== void 0 ? html : rendered.html;
+      text = text !== null && text !== void 0 ? text : rendered.text;
+      subject = subject !== null && subject !== void 0 ? subject : rendered.subject;
+    }
+    if (!subject) {
+      throw new Error('Email subject is required');
+    }
+    const from = (_options$from = options.from) !== null && _options$from !== void 0 ? _options$from : this.config.from;
+    if (!from) {
+      throw new Error('Email "from" address is required. Set it in config.email.from or pass it in the send options.');
+    }
+    const ccAddresses = options.cc ? normalizeRecipients(Array.isArray(options.cc) ? options.cc : [options.cc]) : undefined;
+    const bccAddresses = options.bcc ? normalizeRecipients(Array.isArray(options.bcc) ? options.bcc : [options.bcc]) : undefined;
+    const replyToAddresses = options.replyTo ? normalizeRecipients(Array.isArray(options.replyTo) ? options.replyTo : [options.replyTo]) : this.config.replyTo ? normalizeRecipients(this.config.replyTo) : undefined;
+    const message = {
+      from: typeof from === 'string' ? from : from.name ? `"${from.name}" <${from.address}>` : from.address,
+      to: effectiveTo,
+      cc: ccAddresses,
+      bcc: bccAddresses,
+      replyTo: replyToAddresses,
+      subject,
+      html,
+      text,
+      attachments: options.attachments,
+      headers: {
+        ...this.config.headers,
+        ...options.headers
+      }
+    };
+
+    // In dev mode, optionally write the rendered HTML to disk for browser preview.
+    if (this.isDevMode() && (_this$config$developm2 = this.config.development) !== null && _this$config$developm2 !== void 0 && _this$config$developm2.previewPath && html) {
+      await this.writePreview(this.config.development.previewPath, options.template, html);
+    }
+    const result = await this.transport.send(message);
+    const info = {
+      messageId: result.messageId,
+      accepted: result.accepted,
+      rejected: result.rejected,
+      response: result.response,
+      timestamp: new Date()
+    };
+    try {
+      var _this$config$onSent, _this$config2;
+      await ((_this$config$onSent = (_this$config2 = this.config).onSent) === null || _this$config$onSent === void 0 ? void 0 : _this$config$onSent.call(_this$config2, info, options));
+    } catch {
+      // a failing onSent callback must not fail an already-sent email
+    }
+    return info;
+  }
+}
+
+function createEmail(config) {
+  return new EmailService(config);
+}
+
+export { EmailService, createEmail };