@nuntly/better-email 1.0.0

package/dist/index.mjs

@@ -0,0 +1,528 @@
+function resolveRecipient(context) {
+  if ("user" in context && context.user?.email) return context.user.email;
+  if ("email" in context && context.email) return context.email;
+  throw new Error(`[better-email] Cannot resolve recipient from email type: ${context.type}`);
+}
+function toError(value) {
+  return value instanceof Error ? value : new Error(String(value));
+}
+async function sendEmail(options, context) {
+  const { provider, templateRenderer, defaultTags, tags, onBeforeSend, onAfterSend, onSendError } = options;
+  let message;
+  try {
+    const rendered = await templateRenderer.render(context);
+    const to = resolveRecipient(context);
+    const mergedTags = [
+      ...defaultTags ?? [],
+      ...tags?.[context.type] ?? [],
+      { name: "type", value: context.type }
+    ];
+    message = {
+      to,
+      subject: rendered.subject,
+      html: rendered.html,
+      text: rendered.text,
+      tags: mergedTags
+    };
+    if (onBeforeSend) {
+      const result = await onBeforeSend(context, message);
+      if (result === false) {
+        return { success: true, skipped: true };
+      }
+    }
+    const sendResponse = await provider.send(message);
+    try {
+      if (onAfterSend) {
+        await onAfterSend(context, message);
+      }
+    } catch {
+    }
+    return { success: true, messageId: sendResponse?.messageId };
+  } catch (error) {
+    const emailError = toError(error);
+    if (onSendError && message) {
+      try {
+        await onSendError(context, message, emailError);
+      } catch {
+      }
+    }
+    return { success: false, error: emailError };
+  }
+}
+
+class ConsoleProvider {
+  async send(message) {
+    console.log("[ConsoleProvider] Sending email:", {
+      to: message.to,
+      subject: message.subject,
+      tags: message.tags,
+      htmlLength: message.html.length,
+      textLength: message.text.length
+    });
+  }
+}
+
+class MailgunProvider {
+  apiKey;
+  domain;
+  from;
+  baseUrl;
+  timeout;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.domain = options.domain;
+    this.from = options.from;
+    this.baseUrl = options.baseUrl ?? "https://api.mailgun.net";
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async send(message) {
+    const form = new FormData();
+    form.append("from", this.from);
+    form.append("to", message.to);
+    form.append("subject", message.subject);
+    form.append("html", message.html);
+    form.append("text", message.text);
+    if (message.tags) {
+      for (const tag of message.tags) {
+        form.append("o:tag", tag.value);
+      }
+    }
+    const response = await fetch(`${this.baseUrl}/v3/${this.domain}/messages`, {
+      method: "POST",
+      headers: {
+        Authorization: `Basic ${btoa(`api:${this.apiKey}`)}`
+      },
+      body: form,
+      signal: AbortSignal.timeout(this.timeout)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Mailgun API error (${response.status}): ${body}`);
+    }
+    const data = await response.json().catch(() => ({}));
+    return { messageId: typeof data.id === "string" ? data.id : void 0 };
+  }
+}
+
+class NuntlyProvider {
+  apiKey;
+  from;
+  baseUrl;
+  timeout;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.from = options.from;
+    this.baseUrl = options.baseUrl ?? "https://api.nuntly.com";
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async send(message) {
+    const response = await fetch(`${this.baseUrl}/emails`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        from: this.from,
+        to: message.to,
+        subject: message.subject,
+        html: message.html,
+        text: message.text,
+        tags: message.tags,
+        headers: {
+          "X-Entity-Ref-ID": crypto.randomUUID()
+        }
+      }),
+      signal: AbortSignal.timeout(this.timeout)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Nuntly API error (${response.status}): ${body}`);
+    }
+    const data = await response.json().catch(() => ({}));
+    return { messageId: typeof data.id === "string" ? data.id : void 0 };
+  }
+}
+
+class PostmarkProvider {
+  serverToken;
+  from;
+  messageStream;
+  baseUrl;
+  timeout;
+  constructor(options) {
+    this.serverToken = options.serverToken;
+    this.from = options.from;
+    this.messageStream = options.messageStream;
+    this.baseUrl = options.baseUrl ?? "https://api.postmarkapp.com";
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async send(message) {
+    const body = {
+      From: this.from,
+      To: message.to,
+      Subject: message.subject,
+      HtmlBody: message.html,
+      TextBody: message.text
+    };
+    if (this.messageStream) {
+      body.MessageStream = this.messageStream;
+    }
+    if (message.tags?.length) {
+      body.Tag = message.tags[0].value;
+      body.Headers = message.tags.map((t) => ({
+        Name: `X-Tag-${t.name}`,
+        Value: t.value
+      }));
+    }
+    const response = await fetch(`${this.baseUrl}/email`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        "X-Postmark-Server-Token": this.serverToken
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(this.timeout)
+    });
+    if (!response.ok) {
+      const responseBody = await response.text().catch(() => "");
+      throw new Error(`Postmark API error (${response.status}): ${responseBody}`);
+    }
+    const data = await response.json().catch(() => ({}));
+    return { messageId: typeof data.MessageID === "string" ? data.MessageID : void 0 };
+  }
+}
+
+class ResendProvider {
+  apiKey;
+  from;
+  baseUrl;
+  timeout;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.from = options.from;
+    this.baseUrl = options.baseUrl ?? "https://api.resend.com";
+    this.timeout = options.timeout ?? 3e4;
+  }
+  async send(message) {
+    const response = await fetch(`${this.baseUrl}/emails`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        from: this.from,
+        to: message.to,
+        subject: message.subject,
+        html: message.html,
+        text: message.text,
+        tags: message.tags?.map((t) => ({ name: t.name, value: t.value }))
+      }),
+      signal: AbortSignal.timeout(this.timeout)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Resend API error (${response.status}): ${body}`);
+    }
+    const data = await response.json().catch(() => ({}));
+    return { messageId: typeof data.id === "string" ? data.id : void 0 };
+  }
+}
+
+class SESProvider {
+  client;
+  SendEmailCommand;
+  from;
+  configurationSetName;
+  constructor(options) {
+    this.client = options.client;
+    this.SendEmailCommand = options.SendEmailCommand;
+    this.from = options.from;
+    this.configurationSetName = options.configurationSetName;
+  }
+  async send(message) {
+    const input = {
+      FromEmailAddress: this.from,
+      Destination: { ToAddresses: [message.to] },
+      Content: {
+        Simple: {
+          Subject: { Data: message.subject, Charset: "UTF-8" },
+          Body: {
+            Html: { Data: message.html, Charset: "UTF-8" },
+            Text: { Data: message.text, Charset: "UTF-8" }
+          }
+        }
+      },
+      ...message.tags && {
+        EmailTags: message.tags.map((t) => ({ Name: t.name, Value: t.value }))
+      },
+      ...this.configurationSetName && {
+        ConfigurationSetName: this.configurationSetName
+      }
+    };
+    const command = new this.SendEmailCommand(input);
+    const result = await this.client.send(command);
+    return { messageId: typeof result?.MessageId === "string" ? result.MessageId : void 0 };
+  }
+}
+
+class SMTPProvider {
+  transporter;
+  from;
+  constructor(options) {
+    this.transporter = options.transporter;
+    this.from = options.from;
+  }
+  async send(message) {
+    const result = await this.transporter.sendMail({
+      from: this.from,
+      to: message.to,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      headers: message.tags ? Object.fromEntries(message.tags.map((t) => [`X-Tag-${t.name}`, t.value])) : void 0
+    });
+    return { messageId: typeof result?.messageId === "string" ? result.messageId : void 0 };
+  }
+}
+
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+class DefaultTemplateRenderer {
+  async render(context) {
+    switch (context.type) {
+      case "verification-email":
+        return {
+          subject: "Verify your email",
+          html: `<p>Click the link to verify your email: <a href="${escapeHtml(context.url)}">${escapeHtml(context.url)}</a></p>`,
+          text: `Click the link to verify your email: ${context.url}`
+        };
+      case "reset-password":
+        return {
+          subject: "Reset your password",
+          html: `<p>Click the link to reset your password: <a href="${escapeHtml(context.url)}">${escapeHtml(context.url)}</a></p>`,
+          text: `Click the link to reset your password: ${context.url}`
+        };
+      case "change-email-verification":
+        return {
+          subject: "Confirm your email change",
+          html: `<p>Click the link to confirm changing your email to ${escapeHtml(context.newEmail)}: <a href="${escapeHtml(context.url)}">${escapeHtml(context.url)}</a></p>`,
+          text: `Click the link to confirm changing your email to ${context.newEmail}: ${context.url}`
+        };
+      case "delete-account-verification":
+        return {
+          subject: "Confirm account deletion",
+          html: `<p>Click the link to confirm deleting your account: <a href="${escapeHtml(context.url)}">${escapeHtml(context.url)}</a></p>`,
+          text: `Click the link to confirm deleting your account: ${context.url}`
+        };
+      case "magic-link":
+        return {
+          subject: "Your sign-in link",
+          html: `<p>Click the link to sign in: <a href="${escapeHtml(context.url)}">${escapeHtml(context.url)}</a></p>`,
+          text: `Click the link to sign in: ${context.url}`
+        };
+      case "verification-otp":
+        return {
+          subject: "Your verification code",
+          html: `<p>Your verification code is: <strong>${escapeHtml(context.otp)}</strong></p>`,
+          text: `Your verification code is: ${context.otp}`
+        };
+      case "organization-invitation":
+        return {
+          subject: `You've been invited to join ${context.organization.name}`,
+          html: `<p>You've been invited to join <strong>${escapeHtml(context.organization.name)}</strong>.</p>`,
+          text: `You've been invited to join ${context.organization.name}.`
+        };
+      case "two-factor-otp":
+        return {
+          subject: "Your two-factor authentication code",
+          html: `<p>Your two-factor code is: <strong>${escapeHtml(context.otp)}</strong></p>`,
+          text: `Your two-factor code is: ${context.otp}`
+        };
+      default: {
+        const _exhaustive = context;
+        throw new Error(`[DefaultTemplateRenderer] Unknown email type: ${_exhaustive.type}`);
+      }
+    }
+  }
+}
+
+class MJMLRenderer {
+  constructor(options) {
+    this.options = options;
+  }
+  async render(context) {
+    const templateFn = this.options.templates[context.type];
+    if (!templateFn) {
+      if (this.options.fallback) {
+        return this.options.fallback.render(context);
+      }
+      throw new Error(`[MJMLRenderer] No template found for email type: ${context.type}`);
+    }
+    const { subject, mjml, text } = templateFn(context);
+    const html = this.options.compile(mjml);
+    return { subject, html, text };
+  }
+}
+
+class MustacheRenderer {
+  constructor(options) {
+    this.options = options;
+  }
+  async render(context) {
+    const templateFn = this.options.templates[context.type];
+    if (!templateFn) {
+      if (this.options.fallback) {
+        return this.options.fallback.render(context);
+      }
+      throw new Error(`[MustacheRenderer] No template found for email type: ${context.type}`);
+    }
+    const { subject, template, text } = templateFn(context);
+    const html = this.options.render(template, context);
+    return { subject, html, text };
+  }
+}
+
+function resolveSubject(rendererName, subjects, context) {
+  const resolver = subjects[context.type];
+  if (!resolver) {
+    throw new Error(`[${rendererName}] No subject found for email type: ${context.type}`);
+  }
+  return typeof resolver === "function" ? resolver(context) : resolver;
+}
+
+class ReactEmailRenderer {
+  constructor(options) {
+    this.options = options;
+  }
+  async render(context) {
+    const Component = this.options.templates[context.type];
+    if (!Component) {
+      if (this.options.fallback) {
+        return this.options.fallback.render(context);
+      }
+      throw new Error(`[ReactEmailRenderer] No template found for email type: ${context.type}`);
+    }
+    const element = this.options.createElement(Component, context);
+    const [html, text] = await Promise.all([
+      this.options.render(element),
+      this.options.renderPlainText ? Promise.resolve(this.options.renderPlainText(element)) : this.options.render(element, { plainText: true })
+    ]);
+    const subject = resolveSubject("ReactEmailRenderer", this.options.subjects, context);
+    return { subject, html, text };
+  }
+}
+
+class ReactMJMLRenderer {
+  constructor(options) {
+    this.options = options;
+  }
+  async render(context) {
+    const Component = this.options.templates[context.type];
+    if (!Component) {
+      if (this.options.fallback) {
+        return this.options.fallback.render(context);
+      }
+      throw new Error(`[ReactMJMLRenderer] No template found for email type: ${context.type}`);
+    }
+    const element = this.options.createElement(Component, context);
+    const { html } = this.options.render(element);
+    const subject = resolveSubject("ReactMJMLRenderer", this.options.subjects, context);
+    return {
+      subject,
+      html,
+      text: this.htmlToPlainText(html)
+    };
+  }
+  /**
+   * Converts HTML to plain text with basic formatting preservation.
+   * Handles line breaks, links, lists, and common block elements.
+   */
+  htmlToPlainText(html) {
+    let text = html;
+    text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "");
+    text = text.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "");
+    text = text.replace(/<\/(div|p|h[1-6]|li|tr|table)>/gi, "\n");
+    text = text.replace(/<br\s*\/?>/gi, "\n");
+    text = text.replace(/<\/td>/gi, "	");
+    text = text.replace(/<a[^>]*href=["']([^"']+)["'][^>]*>(.*?)<\/a>/gi, (_, href, linkText) => {
+      const cleanText = linkText.replace(/<[^>]+>/g, "").trim();
+      return cleanText === href ? href : `${cleanText} (${href})`;
+    });
+    text = text.replace(/<[^>]+>/g, "");
+    text = text.replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&#x([0-9A-Fa-f]+);/g, (_, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+    text = text.replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+    return text;
+  }
+}
+
+const betterEmail = (options) => {
+  return {
+    id: "better-email",
+    helpers: {
+      changeEmail: betterEmailChangeEmail(options),
+      deleteAccount: betterEmailDeleteAccount(options),
+      magicLink: betterEmailMagicLink(options),
+      otp: betterEmailOTP(options),
+      invitation: betterEmailInvitation(options),
+      twoFactor: betterEmailTwoFactor(options)
+    },
+    init() {
+      return {
+        options: {
+          emailVerification: {
+            sendVerificationEmail: async (data) => {
+              await sendEmail(options, { type: "verification-email", ...data });
+            }
+          },
+          emailAndPassword: {
+            enabled: true,
+            sendResetPassword: async (data) => {
+              await sendEmail(options, { type: "reset-password", ...data });
+            }
+          }
+        }
+      };
+    }
+  };
+};
+function betterEmailChangeEmail(options) {
+  return async (data) => {
+    await sendEmail(options, { type: "change-email-verification", ...data });
+  };
+}
+function betterEmailDeleteAccount(options) {
+  return async (data) => {
+    await sendEmail(options, { type: "delete-account-verification", ...data });
+  };
+}
+function betterEmailMagicLink(options) {
+  return async (data) => {
+    await sendEmail(options, { type: "magic-link", ...data });
+  };
+}
+function betterEmailOTP(options) {
+  return async (data) => {
+    await sendEmail(options, {
+      type: "verification-otp",
+      email: data.email,
+      otp: data.otp,
+      otpType: data.type
+    });
+  };
+}
+function betterEmailInvitation(options) {
+  return async (data) => {
+    await sendEmail(options, { type: "organization-invitation", ...data });
+  };
+}
+function betterEmailTwoFactor(options) {
+  return async (data) => {
+    await sendEmail(options, { type: "two-factor-otp", ...data });
+  };
+}
+
+export { ConsoleProvider, DefaultTemplateRenderer, MJMLRenderer, MailgunProvider, MustacheRenderer, NuntlyProvider, PostmarkProvider, ReactEmailRenderer, ReactMJMLRenderer, ResendProvider, SESProvider, SMTPProvider, betterEmail, betterEmailChangeEmail, betterEmailDeleteAccount, betterEmailInvitation, betterEmailMagicLink, betterEmailOTP, betterEmailTwoFactor, sendEmail };

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@nuntly/better-email",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "author": "Nuntly",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nuntly/better-email.git",
+    "directory": "packages/better-email"
+  },
+  "homepage": "https://github.com/nuntly/better-email#readme",
+  "bugs": {
+    "url": "https://github.com/nuntly/better-email/issues"
+  },
+  "keywords": [
+    "auth",
+    "email",
+    "better-auth",
+    "nuntly",
+    "react-email",
+    "react-mjml",
+    "mustache"
+  ],
+  "description": "Better Auth emails made simple with Better Email",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prebuild": "rimraf dist",
+    "build": "unbuild",
+    "dev": "unbuild --watch",
+    "test": "vitest",
+    "typecheck": "tsc --project tsconfig.json --noEmit"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "dependencies": {},
+  "peerDependencies": {
+    "better-auth": ">=1.3.27"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.0.0",
+    "rimraf": "~6.1.2",
+    "unbuild": "3.6.1",
+    "vitest": "^2.0.0"
+  }
+}