@razmatinyan/nuxt-email 0.1.0

package/dist/runtime/server/utils/providers/fetch.d.ts

@@ -0,0 +1 @@
+declare const $fetch: typeof import('ofetch').$fetch

package/dist/runtime/server/utils/providers/index.d.ts

@@ -0,0 +1,9 @@
+import type { EmailProvider, EmailRuntimeConfig } from '../../../types/index.js.js';
+type ProviderName = 'console' | 'resend' | 'sendgrid' | 'postmark' | 'smtp';
+export declare const VALID_PROVIDERS: ProviderName[];
+export declare function createProvider(name: string, config: EmailRuntimeConfig): EmailProvider;
+export { ConsoleProvider } from './console.js.js';
+export { ResendProvider } from './resend.js.js';
+export { SendGridProvider } from './sendgrid.js.js';
+export { PostmarkProvider } from './postmark.js.js';
+export { SmtpProvider } from './smtp.js.js';

package/dist/runtime/server/utils/providers/index.js

@@ -0,0 +1,33 @@
+import { ConsoleProvider } from "./console.js";
+import { ResendProvider } from "./resend.js";
+import { SendGridProvider } from "./sendgrid.js";
+import { PostmarkProvider } from "./postmark.js";
+import { SmtpProvider } from "./smtp.js";
+export const VALID_PROVIDERS = [
+  "console",
+  "resend",
+  "sendgrid",
+  "postmark",
+  "smtp"
+];
+const factories = {
+  console: () => new ConsoleProvider(),
+  resend: (config) => new ResendProvider(config),
+  sendgrid: (config) => new SendGridProvider(config),
+  postmark: (config) => new PostmarkProvider(config),
+  smtp: (config) => new SmtpProvider(config)
+};
+export function createProvider(name, config) {
+  const factory = factories[name];
+  if (!factory) {
+    throw new Error(
+      `[nuxt-email] Unknown provider "${name}". Valid providers: ${VALID_PROVIDERS.join(", ")}`
+    );
+  }
+  return factory(config);
+}
+export { ConsoleProvider } from "./console.js";
+export { ResendProvider } from "./resend.js";
+export { SendGridProvider } from "./sendgrid.js";
+export { PostmarkProvider } from "./postmark.js";
+export { SmtpProvider } from "./smtp.js";

package/dist/runtime/server/utils/providers/postmark.d.ts

@@ -0,0 +1,8 @@
+import type { EmailProvider, EmailRuntimeConfig, NormalizedPayload, EmailResponse } from '../../../types/index.js.js';
+export declare class PostmarkProvider implements EmailProvider {
+    name: string;
+    private readonly apiKey;
+    constructor(config: EmailRuntimeConfig);
+    send(payload: NormalizedPayload): Promise<EmailResponse>;
+    verify(): Promise<boolean>;
+}

package/dist/runtime/server/utils/providers/postmark.js

@@ -0,0 +1,94 @@
+import { toBase64, fetchErrorMessage, omitUndefined } from "./shared.js";
+export class PostmarkProvider {
+  name = "postmark";
+  apiKey;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("[nuxt-email] PostmarkProvider requires `apiKey`.");
+    }
+    this.apiKey = config.apiKey;
+  }
+  async send(payload) {
+    const start = Date.now();
+    try {
+      const headers = payload.headers ? Object.entries(payload.headers).map(([Name, Value]) => ({
+        Name,
+        Value
+      })) : void 0;
+      const attachments = payload.attachments?.map(
+        (a) => omitUndefined({
+          Name: a.filename,
+          Content: toBase64(a.content),
+          ContentType: a.contentType ?? "application/octet-stream",
+          ContentID: a.cid
+        })
+      );
+      const body = omitUndefined({
+        From: payload.from,
+        To: payload.to.join(","),
+        Cc: payload.cc?.join(","),
+        Bcc: payload.bcc?.join(","),
+        ReplyTo: payload.replyTo,
+        Subject: payload.subject,
+        HtmlBody: payload.html,
+        TextBody: payload.text,
+        Headers: headers,
+        Attachments: attachments,
+        Metadata: payload.tags,
+        MessageStream: "outbound"
+      });
+      const res = await $fetch("https://api.postmarkapp.com/email", {
+        method: "POST",
+        headers: {
+          "X-Postmark-Server-Token": this.apiKey,
+          Accept: "application/json",
+          "Content-Type": "application/json"
+        },
+        body
+      });
+      if (res.ErrorCode !== 0) {
+        return {
+          success: false,
+          error: `[nuxt-email] Postmark error: ${res.Message}`,
+          provider: this.name,
+          duration: Date.now() - start
+        };
+      }
+      return {
+        success: true,
+        messageId: res.MessageID,
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    } catch (error) {
+      const data = error?.data;
+      if (data?.ErrorCode !== void 0 && data.ErrorCode !== 0) {
+        return {
+          success: false,
+          error: `[nuxt-email] Postmark error: ${data.Message ?? "Unknown error"}`,
+          provider: this.name,
+          duration: Date.now() - start
+        };
+      }
+      return {
+        success: false,
+        error: fetchErrorMessage("Postmark", error),
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    }
+  }
+  async verify() {
+    try {
+      await $fetch("https://api.postmarkapp.com/server", {
+        headers: {
+          "X-Postmark-Server-Token": this.apiKey,
+          Accept: "application/json"
+        }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/runtime/server/utils/providers/resend.d.ts

@@ -0,0 +1,8 @@
+import type { EmailProvider, EmailRuntimeConfig, NormalizedPayload, EmailResponse } from '../../../types/index.js.js';
+export declare class ResendProvider implements EmailProvider {
+    name: string;
+    private readonly apiKey;
+    constructor(config: EmailRuntimeConfig);
+    send(payload: NormalizedPayload): Promise<EmailResponse>;
+    verify(): Promise<boolean>;
+}

package/dist/runtime/server/utils/providers/resend.js

@@ -0,0 +1,73 @@
+import { toBase64, fetchErrorMessage, omitUndefined } from "./shared.js";
+export class ResendProvider {
+  name = "resend";
+  apiKey;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("[nuxt-email] ResendProvider requires `apiKey`.");
+    }
+    this.apiKey = config.apiKey;
+  }
+  async send(payload) {
+    const start = Date.now();
+    try {
+      const attachments = payload.attachments?.map(
+        (a) => omitUndefined({
+          filename: a.filename,
+          content: toBase64(a.content),
+          content_type: a.contentType,
+          content_id: a.cid
+        })
+      );
+      const tags = payload.tags ? Object.entries(payload.tags).map(([name, value]) => ({
+        name,
+        value
+      })) : void 0;
+      const body = omitUndefined({
+        from: payload.from,
+        to: payload.to,
+        cc: payload.cc,
+        bcc: payload.bcc,
+        reply_to: payload.replyTo,
+        subject: payload.subject,
+        html: payload.html,
+        text: payload.text,
+        headers: payload.headers,
+        attachments,
+        tags,
+        scheduled_at: payload.scheduledAt?.toISOString()
+      });
+      const res = await $fetch(
+        "https://api.resend.com/emails",
+        {
+          method: "POST",
+          headers: { Authorization: `Bearer ${this.apiKey}` },
+          body
+        }
+      );
+      return {
+        success: true,
+        messageId: res.id,
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: fetchErrorMessage("Resend", error),
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    }
+  }
+  async verify() {
+    try {
+      await $fetch("https://api.resend.com/domains", {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/runtime/server/utils/providers/sendgrid.d.ts

@@ -0,0 +1,8 @@
+import type { EmailProvider, EmailRuntimeConfig, NormalizedPayload, EmailResponse } from '../../../types/index.js.js';
+export declare class SendGridProvider implements EmailProvider {
+    name: string;
+    private readonly apiKey;
+    constructor(config: EmailRuntimeConfig);
+    send(payload: NormalizedPayload): Promise<EmailResponse>;
+    verify(): Promise<boolean>;
+}

package/dist/runtime/server/utils/providers/sendgrid.js

@@ -0,0 +1,99 @@
+import {
+  toBase64,
+  parseAddress,
+  fetchErrorMessage,
+  omitUndefined
+} from "./shared.js";
+export class SendGridProvider {
+  name = "sendgrid";
+  apiKey;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("[nuxt-email] SendGridProvider requires `apiKey`.");
+    }
+    this.apiKey = config.apiKey;
+  }
+  async send(payload) {
+    const start = Date.now();
+    try {
+      const personalization = {
+        to: payload.to.map((e) => ({ email: e }))
+      };
+      if (payload.cc?.length)
+        personalization.cc = payload.cc.map((e) => ({ email: e }));
+      if (payload.bcc?.length)
+        personalization.bcc = payload.bcc.map((e) => ({ email: e }));
+      if (payload.scheduledAt) {
+        personalization.send_at = Math.floor(
+          payload.scheduledAt.getTime() / 1e3
+        );
+      }
+      const content = [];
+      if (payload.text)
+        content.push({ type: "text/plain", value: payload.text });
+      content.push({ type: "text/html", value: payload.html });
+      const attachments = payload.attachments?.map(
+        (a) => omitUndefined({
+          filename: a.filename,
+          content: toBase64(a.content),
+          type: a.contentType,
+          disposition: a.disposition,
+          content_id: a.cid
+        })
+      );
+      const body = omitUndefined({
+        personalizations: [personalization],
+        from: parseAddress(payload.from),
+        reply_to: payload.replyTo ? parseAddress(payload.replyTo) : void 0,
+        subject: payload.subject,
+        content,
+        attachments,
+        headers: payload.headers,
+        custom_args: payload.tags
+      });
+      const res = await $fetch.raw(
+        "https://api.sendgrid.com/v3/mail/send",
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body
+        }
+      );
+      if (res.status !== 202) {
+        return {
+          success: false,
+          error: `[nuxt-email] SendGrid API error (${res.status}): unexpected status`,
+          provider: this.name,
+          duration: Date.now() - start
+        };
+      }
+      const messageId = res.headers.get("x-message-id") ?? void 0;
+      return {
+        success: true,
+        messageId,
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: fetchErrorMessage("SendGrid", error),
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    }
+  }
+  async verify() {
+    try {
+      await $fetch("https://api.sendgrid.com/v3/scopes", {
+        headers: { Authorization: `Bearer ${this.apiKey}` }
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/runtime/server/utils/providers/shared.d.ts

@@ -0,0 +1,7 @@
+export declare function toBase64(content: string | Buffer): string;
+export declare function parseAddress(addr: string): {
+    email: string;
+    name?: string;
+};
+export declare function fetchErrorMessage(provider: string, error: unknown): string;
+export declare function omitUndefined<T extends Record<string, unknown>>(obj: T): Partial<T>;

package/dist/runtime/server/utils/providers/shared.js

@@ -0,0 +1,29 @@
+export function toBase64(content) {
+  if (Buffer.isBuffer(content)) return content.toString("base64");
+  return Buffer.from(content).toString("base64");
+}
+export function parseAddress(addr) {
+  const match = addr.match(/^(.+?)\s*<([^>]+)>$/);
+  if (match) return { name: match[1].trim(), email: match[2].trim() };
+  return { email: addr.trim() };
+}
+export function fetchErrorMessage(provider, error) {
+  if (error && typeof error === "object") {
+    const e = error;
+    const status = typeof e.status === "number" ? e.status : void 0;
+    const data = e.data;
+    const message = typeof data?.message === "string" && data.message || typeof data?.Message === "string" && data.Message || typeof e.message === "string" && e.message || "Unknown error";
+    if (status !== void 0) {
+      return `[nuxt-email] ${provider} API error (${status}): ${message}`;
+    }
+    return `[nuxt-email] ${provider} error: ${message}`;
+  }
+  return `[nuxt-email] ${provider} error: ${String(error)}`;
+}
+export function omitUndefined(obj) {
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    if (obj[key] !== void 0) result[key] = obj[key];
+  }
+  return result;
+}

package/dist/runtime/server/utils/providers/smtp.d.ts

@@ -0,0 +1,8 @@
+import type { EmailProvider, EmailRuntimeConfig, NormalizedPayload, EmailResponse } from '../../../types/index.js.js';
+export declare class SmtpProvider implements EmailProvider {
+    name: string;
+    private readonly config;
+    constructor(config: EmailRuntimeConfig);
+    send(payload: NormalizedPayload): Promise<EmailResponse>;
+    verify(): Promise<boolean>;
+}

package/dist/runtime/server/utils/providers/smtp.js

@@ -0,0 +1,85 @@
+export class SmtpProvider {
+  name = "smtp";
+  config;
+  constructor(config) {
+    if (!config.smtpHost) {
+      throw new Error("[nuxt-email] SmtpProvider requires `smtp.host`.");
+    }
+    this.config = config;
+  }
+  async send(payload) {
+    const start = Date.now();
+    try {
+      let nodemailer;
+      try {
+        nodemailer = await import("nodemailer");
+      } catch {
+        return {
+          success: false,
+          error: "[nuxt-email] SMTP requires the optional peer dep `nodemailer`. Run `npm i nodemailer`.",
+          provider: this.name,
+          duration: Date.now() - start
+        };
+      }
+      const { smtpHost, smtpPort, smtpSecure, smtpUser, smtpPass } = this.config;
+      const transporter = nodemailer.createTransport({
+        host: smtpHost,
+        port: smtpPort,
+        secure: smtpSecure || smtpPort === 465,
+        auth: smtpUser ? { user: smtpUser, pass: smtpPass } : void 0
+      });
+      const attachments = payload.attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        contentType: a.contentType,
+        cid: a.cid
+      }));
+      const info = await transporter.sendMail({
+        from: payload.from,
+        to: payload.to,
+        cc: payload.cc,
+        bcc: payload.bcc,
+        replyTo: payload.replyTo,
+        subject: payload.subject,
+        html: payload.html,
+        text: payload.text,
+        headers: payload.headers,
+        attachments
+      });
+      return {
+        success: true,
+        messageId: info.messageId,
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `[nuxt-email] SMTP error: ${error instanceof Error ? error.message : String(error)}`,
+        provider: this.name,
+        duration: Date.now() - start
+      };
+    }
+  }
+  async verify() {
+    try {
+      let nodemailer;
+      try {
+        nodemailer = await import("nodemailer");
+      } catch {
+        return false;
+      }
+      const { smtpHost, smtpPort, smtpSecure, smtpUser, smtpPass } = this.config;
+      const transporter = nodemailer.createTransport({
+        host: smtpHost,
+        port: smtpPort,
+        secure: smtpSecure || smtpPort === 465,
+        auth: smtpUser ? { user: smtpUser, pass: smtpPass } : void 0
+      });
+      await transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/runtime/server/utils/template-renderer.d.ts

@@ -0,0 +1,5 @@
+import type { Component } from 'vue';
+export declare function renderEmailTemplate(component: Component, props?: Record<string, unknown>): Promise<{
+    html: string;
+    text: string;
+}>;

package/dist/runtime/server/utils/template-renderer.js

@@ -0,0 +1,10 @@
+import { createSSRApp } from "@vue/runtime-dom";
+import { renderToString } from "@vue/server-renderer";
+import juice from "juice";
+export async function renderEmailTemplate(component, props = {}) {
+  const app = createSSRApp(component, props);
+  const rendered = await renderToString(app);
+  const html = juice(rendered);
+  const text = rendered.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  return { html, text };
+}

package/dist/runtime/server/utils/templates.d.ts

@@ -0,0 +1,4 @@
+import type { Component } from 'vue';
+export declare function getEmailTemplate(name: string): Component;
+export declare function getPreviewProps(name: string): Record<string, unknown>;
+export declare function listTemplates(): string[];

package/dist/runtime/server/utils/templates.js

@@ -0,0 +1,17 @@
+import { templates, previewProps } from "#nuxt-email/templates";
+export function getEmailTemplate(name) {
+  const component = templates[name];
+  if (!component) {
+    const available = Object.keys(templates).join(", ") || "none";
+    throw new Error(
+      `[nuxt-email] Template "${name}" not found. Available: ${available}`
+    );
+  }
+  return component;
+}
+export function getPreviewProps(name) {
+  return previewProps[name] ?? {};
+}
+export function listTemplates() {
+  return Object.keys(templates);
+}

package/dist/runtime/templates.d.ts

@@ -0,0 +1,6 @@
+declare module '#nuxt-email/templates' {
+	import type { Component } from 'vue'
+
+	export const templates: Record<string, Component>
+	export const previewProps: Record<string, Record<string, unknown>>
+}

package/dist/runtime/types/index.d.ts

@@ -0,0 +1,110 @@
+export interface EmailModuleOptions {
+    /** Email provider. Default: 'console' (logs to terminal) */
+    provider: 'resend' | 'sendgrid' | 'postmark' | 'smtp' | 'console';
+    /** Default sender address: "Name <email>" or "email" */
+    from?: string;
+    /** Provider API key (prefer env vars via runtimeConfig) */
+    apiKey?: string;
+    smtp?: SmtpConfig;
+    /** Per-provider credentials. Each entry overrides the top-level `apiKey`/`smtp`/`from` for that provider. */
+    providers?: Partial<Record<EmailModuleOptions['provider'], ProviderOptions>>;
+    /** Directory for Vue email templates relative to project root. Default: 'server/emails' */
+    templateDir?: string;
+    /** Enable preview route in dev mode. Default: true */
+    preview?: boolean;
+    /** Number of retry attempts on transient failures. Default: 2 */
+    retries?: number;
+    /** Delay between retries in ms. Default: 1000 */
+    retryDelay?: number;
+}
+export interface SmtpConfig {
+    host: string;
+    port?: number;
+    user?: string;
+    pass?: string;
+    secure?: boolean;
+}
+/** Credentials for a single provider, overriding the top-level defaults. */
+export interface ProviderOptions {
+    apiKey?: string;
+    from?: string;
+    smtp?: SmtpConfig;
+}
+/** Flat per-provider overrides stored in runtime config. */
+export interface ProviderRuntimeOptions {
+    apiKey?: string;
+    from?: string;
+    smtpHost?: string;
+    smtpPort?: number;
+    smtpUser?: string;
+    smtpPass?: string;
+    smtpSecure?: boolean;
+}
+/** Stored in runtimeConfig._email. Private, never sent to the client. */
+export interface EmailRuntimeConfig {
+    provider: string;
+    apiKey: string;
+    from: string;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUser: string;
+    smtpPass: string;
+    smtpSecure: boolean;
+    retries: number;
+    retryDelay: number;
+    providers?: Record<string, ProviderRuntimeOptions>;
+}
+export interface EmailPayload {
+    to: string | string[];
+    subject: string;
+    /** Mutually exclusive with `template` */
+    html?: string;
+    text?: string;
+    template?: string;
+    props?: Record<string, unknown>;
+    from?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+    replyTo?: string;
+    attachments?: EmailAttachment[];
+    headers?: Record<string, string>;
+    /** Provider must support scheduled sends */
+    scheduledAt?: Date;
+    /** Provider-dependent */
+    tags?: Record<string, string>;
+}
+export interface EmailAttachment {
+    filename: string;
+    content: string | Buffer;
+    contentType?: string;
+    /** 'attachment' | 'inline' */
+    disposition?: string;
+    /** Content-ID for inline images */
+    cid?: string;
+}
+export interface EmailResponse {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+    provider: string;
+    duration: number;
+}
+export interface EmailProvider {
+    name: string;
+    send(payload: NormalizedPayload): Promise<EmailResponse>;
+    verify?(): Promise<boolean>;
+}
+export interface NormalizedPayload {
+    from: string;
+    to: string[];
+    subject: string;
+    html: string;
+    text?: string;
+    cc?: string[];
+    bcc?: string[];
+    replyTo?: string;
+    attachments?: EmailAttachment[];
+    headers?: Record<string, string>;
+    scheduledAt?: Date;
+    tags?: Record<string, string>;
+}

package/dist/types.d.mts

@@ -0,0 +1,9 @@
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.mjs'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { type EmailAttachment, type EmailModuleOptions, type EmailPayload, type EmailProvider, type EmailResponse, type NormalizedPayload } from '../dist/runtime/types/index.js'
+
+export { default } from './module.mjs'