@shogo-ai/email 1.4.1

package/dist/server.d.cts

@@ -0,0 +1,109 @@
+import { b as EmailConfig, a as EmailAddress, g as IEmailService } from './types-CCHryvHe.cjs';
+export { f as EmailResult, E as EmailTemplate, S as SendEmailParams, h as SendTemplateParams } from './types-CCHryvHe.cjs';
+
+/**
+ * Email Service - Server Side
+ *
+ * Main entry point for server-side email functionality.
+ * Use this in server functions, API routes, etc.
+ *
+ * @example
+ * ```typescript
+ * import { createEmail } from '@shogo-ai/sdk/email/server'
+ *
+ * // Auto-configured from environment variables
+ * const email = createEmail()
+ *
+ * // Send a templated email
+ * await email.sendTemplate({
+ *   to: 'user@example.com',
+ *   template: 'welcome',
+ *   data: { name: 'Alice', appName: 'MyApp' },
+ * })
+ *
+ * // Send raw email
+ * await email.send({
+ *   to: 'user@example.com',
+ *   subject: 'Hello!',
+ *   html: '<h1>Hello World</h1>',
+ * })
+ * ```
+ */
+
+/**
+ * Options for creating an email service
+ */
+interface CreateEmailOptions {
+    /**
+     * Email provider configuration.
+     * If not provided, auto-detects from environment variables.
+     */
+    config?: EmailConfig;
+    /**
+     * Default sender address.
+     * Can also be set via EMAIL_FROM or SMTP_FROM_EMAIL env var.
+     */
+    defaultFrom?: EmailAddress;
+    /**
+     * Include built-in templates (welcome, password-reset, invitation, notification).
+     * Default: true
+     */
+    includeBuiltins?: boolean;
+}
+/**
+ * Create an email service instance.
+ *
+ * If no config is provided, auto-detects provider from environment variables:
+ * - SMTP: SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASSWORD
+ * - SES: AWS_REGION or SES_REGION
+ *
+ * @example
+ * ```typescript
+ * // Auto-configured from env
+ * const email = createEmail()
+ *
+ * // With explicit SMTP config
+ * const email = createEmail({
+ *   config: {
+ *     provider: 'smtp',
+ *     defaultFrom: 'noreply@myapp.com',
+ *     smtp: {
+ *       host: 'smtp.example.com',
+ *       port: 587,
+ *       user: 'user',
+ *       password: 'pass',
+ *     },
+ *   },
+ * })
+ *
+ * // With SES config
+ * const email = createEmail({
+ *   config: {
+ *     provider: 'ses',
+ *     defaultFrom: 'noreply@myapp.com',
+ *     ses: {
+ *       region: 'us-east-1',
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function createEmail(options?: CreateEmailOptions): IEmailService;
+/**
+ * Create an email service, returning null if not configured.
+ * Useful for optional email functionality.
+ *
+ * @example
+ * ```typescript
+ * const email = createEmailOptional()
+ *
+ * if (email) {
+ *   await email.send({ ... })
+ * } else {
+ *   console.log('Email not configured, skipping')
+ * }
+ * ```
+ */
+declare function createEmailOptional(options?: CreateEmailOptions): IEmailService | null;
+
+export { type CreateEmailOptions, EmailConfig, IEmailService, createEmail, createEmailOptional };

package/dist/server.d.ts

@@ -0,0 +1,109 @@
+import { b as EmailConfig, a as EmailAddress, g as IEmailService } from './types-CCHryvHe.js';
+export { f as EmailResult, E as EmailTemplate, S as SendEmailParams, h as SendTemplateParams } from './types-CCHryvHe.js';
+
+/**
+ * Email Service - Server Side
+ *
+ * Main entry point for server-side email functionality.
+ * Use this in server functions, API routes, etc.
+ *
+ * @example
+ * ```typescript
+ * import { createEmail } from '@shogo-ai/sdk/email/server'
+ *
+ * // Auto-configured from environment variables
+ * const email = createEmail()
+ *
+ * // Send a templated email
+ * await email.sendTemplate({
+ *   to: 'user@example.com',
+ *   template: 'welcome',
+ *   data: { name: 'Alice', appName: 'MyApp' },
+ * })
+ *
+ * // Send raw email
+ * await email.send({
+ *   to: 'user@example.com',
+ *   subject: 'Hello!',
+ *   html: '<h1>Hello World</h1>',
+ * })
+ * ```
+ */
+
+/**
+ * Options for creating an email service
+ */
+interface CreateEmailOptions {
+    /**
+     * Email provider configuration.
+     * If not provided, auto-detects from environment variables.
+     */
+    config?: EmailConfig;
+    /**
+     * Default sender address.
+     * Can also be set via EMAIL_FROM or SMTP_FROM_EMAIL env var.
+     */
+    defaultFrom?: EmailAddress;
+    /**
+     * Include built-in templates (welcome, password-reset, invitation, notification).
+     * Default: true
+     */
+    includeBuiltins?: boolean;
+}
+/**
+ * Create an email service instance.
+ *
+ * If no config is provided, auto-detects provider from environment variables:
+ * - SMTP: SMTP_HOST, SMTP_PORT, SMTP_USER, SMTP_PASSWORD
+ * - SES: AWS_REGION or SES_REGION
+ *
+ * @example
+ * ```typescript
+ * // Auto-configured from env
+ * const email = createEmail()
+ *
+ * // With explicit SMTP config
+ * const email = createEmail({
+ *   config: {
+ *     provider: 'smtp',
+ *     defaultFrom: 'noreply@myapp.com',
+ *     smtp: {
+ *       host: 'smtp.example.com',
+ *       port: 587,
+ *       user: 'user',
+ *       password: 'pass',
+ *     },
+ *   },
+ * })
+ *
+ * // With SES config
+ * const email = createEmail({
+ *   config: {
+ *     provider: 'ses',
+ *     defaultFrom: 'noreply@myapp.com',
+ *     ses: {
+ *       region: 'us-east-1',
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function createEmail(options?: CreateEmailOptions): IEmailService;
+/**
+ * Create an email service, returning null if not configured.
+ * Useful for optional email functionality.
+ *
+ * @example
+ * ```typescript
+ * const email = createEmailOptional()
+ *
+ * if (email) {
+ *   await email.send({ ... })
+ * } else {
+ *   console.log('Email not configured, skipping')
+ * }
+ * ```
+ */
+declare function createEmailOptional(options?: CreateEmailOptions): IEmailService | null;
+
+export { type CreateEmailOptions, EmailConfig, IEmailService, createEmail, createEmailOptional };

package/dist/server.js

@@ -0,0 +1,404 @@
+import {
+  EmailError,
+  EmailTemplateRegistry,
+  createShogoTemplateRegistry,
+  formatEmailAddress
+} from "./chunk-VPWVZHAC.js";
+
+// src/providers/smtp.ts
+var SmtpProvider = class {
+  // nodemailer.Transporter - lazy loaded
+  constructor(config) {
+    this.validateConfig(config);
+    this.config = config;
+  }
+  /**
+   * Validate required config fields
+   */
+  validateConfig(config) {
+    const required = ["host", "port", "user", "password"];
+    for (const field of required) {
+      if (!config[field]) {
+        throw EmailError.configMissing(`smtp.${field}`);
+      }
+    }
+  }
+  /**
+   * Lazy-load nodemailer and create transporter
+   */
+  async getTransporter() {
+    if (this.transporter) {
+      return this.transporter;
+    }
+    const nodemailer = await import("nodemailer");
+    this.transporter = nodemailer.createTransport({
+      host: this.config.host,
+      port: this.config.port,
+      secure: this.config.secure ?? this.config.port === 465,
+      auth: {
+        user: this.config.user,
+        pass: this.config.password
+      }
+    });
+    return this.transporter;
+  }
+  /**
+   * Format recipients for nodemailer
+   */
+  formatRecipients(addresses) {
+    const list = Array.isArray(addresses) ? addresses : [addresses];
+    return list.map(formatEmailAddress).join(", ");
+  }
+  /**
+   * Strip HTML tags to create plain text version
+   */
+  stripHtml(html) {
+    return html.replace(/<style[^>]*>.*?<\/style>/gi, "").replace(/<script[^>]*>.*?<\/script>/gi, "").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Check if provider is configured
+   */
+  isConfigured() {
+    return !!(this.config.host && this.config.port && this.config.user && this.config.password);
+  }
+  /**
+   * Send an email via SMTP
+   */
+  async send(params) {
+    const { to, subject, html, text, from, replyTo, cc, bcc } = params;
+    if (!from) {
+      throw EmailError.configMissing("from address");
+    }
+    try {
+      const transporter = await this.getTransporter();
+      const mailOptions = {
+        from: formatEmailAddress(from),
+        to: this.formatRecipients(to),
+        subject,
+        html,
+        text: text || this.stripHtml(html)
+      };
+      if (replyTo) {
+        mailOptions.replyTo = formatEmailAddress(replyTo);
+      }
+      if (cc) {
+        mailOptions.cc = this.formatRecipients(cc);
+      }
+      if (bcc) {
+        mailOptions.bcc = this.formatRecipients(bcc);
+      }
+      const info = await transporter.sendMail(mailOptions);
+      return {
+        success: true,
+        messageId: info.messageId
+      };
+    } catch (error) {
+      const errorMessage = error.message || "Failed to send email";
+      const errorCode = this.mapErrorCode(error);
+      return {
+        success: false,
+        error: `[${errorCode}] ${errorMessage}`
+      };
+    }
+  }
+  /**
+   * Map nodemailer error to error code
+   */
+  mapErrorCode(error) {
+    const code = error.code || error.errno || "";
+    const message = (error.message || "").toLowerCase();
+    if (code === "ECONNREFUSED" || code === "ENOTFOUND" || message.includes("connection")) {
+      return "connection_error";
+    }
+    if (code === "EAUTH" || message.includes("auth") || message.includes("credentials")) {
+      return "authentication_error";
+    }
+    if (message.includes("recipient") || message.includes("mailbox") || message.includes("not found")) {
+      return "invalid_recipient";
+    }
+    return "send_failed";
+  }
+};
+function createSmtpProviderFromEnv() {
+  const host = process.env.SMTP_HOST;
+  const port = process.env.SMTP_PORT;
+  const user = process.env.SMTP_USER;
+  const password = process.env.SMTP_PASSWORD;
+  if (!host || !port || !user || !password) {
+    return null;
+  }
+  return new SmtpProvider({
+    host,
+    port: parseInt(port, 10),
+    user,
+    password,
+    secure: process.env.SMTP_SECURE === "true" ? true : void 0
+  });
+}
+
+// src/providers/ses.ts
+var SesProvider = class {
+  // SESClient - lazy loaded
+  constructor(config) {
+    this.validateConfig(config);
+    this.config = config;
+  }
+  /**
+   * Validate required config fields
+   */
+  validateConfig(config) {
+    if (!config.region) {
+      throw EmailError.configMissing("ses.region");
+    }
+  }
+  /**
+   * Lazy-load AWS SDK and create client
+   */
+  async getClient() {
+    if (this.client) {
+      return this.client;
+    }
+    const { SESClient } = await import("@aws-sdk/client-ses");
+    const clientConfig = {
+      region: this.config.region
+    };
+    if (this.config.accessKeyId && this.config.secretAccessKey) {
+      clientConfig.credentials = {
+        accessKeyId: this.config.accessKeyId,
+        secretAccessKey: this.config.secretAccessKey
+      };
+    }
+    this.client = new SESClient(clientConfig);
+    return this.client;
+  }
+  /**
+   * Format recipients as array of strings
+   */
+  formatRecipients(addresses) {
+    const list = Array.isArray(addresses) ? addresses : [addresses];
+    return list.map(
+      (addr) => typeof addr === "string" ? addr : addr.email
+    );
+  }
+  /**
+   * Strip HTML tags to create plain text version
+   */
+  stripHtml(html) {
+    return html.replace(/<style[^>]*>.*?<\/style>/gi, "").replace(/<script[^>]*>.*?<\/script>/gi, "").replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+  }
+  /**
+   * Check if provider is configured
+   */
+  isConfigured() {
+    return !!this.config.region;
+  }
+  /**
+   * Send an email via SES
+   */
+  async send(params) {
+    const { to, subject, html, text, from, replyTo, cc, bcc } = params;
+    if (!from) {
+      throw EmailError.configMissing("from address");
+    }
+    try {
+      const client = await this.getClient();
+      const { SendEmailCommand } = await import("@aws-sdk/client-ses");
+      const destination = {
+        ToAddresses: this.formatRecipients(to)
+      };
+      if (cc) {
+        destination.CcAddresses = this.formatRecipients(cc);
+      }
+      if (bcc) {
+        destination.BccAddresses = this.formatRecipients(bcc);
+      }
+      const command = new SendEmailCommand({
+        Source: formatEmailAddress(from),
+        Destination: destination,
+        Message: {
+          Subject: {
+            Data: subject,
+            Charset: "UTF-8"
+          },
+          Body: {
+            Html: {
+              Data: html,
+              Charset: "UTF-8"
+            },
+            Text: {
+              Data: text || this.stripHtml(html),
+              Charset: "UTF-8"
+            }
+          }
+        },
+        ReplyToAddresses: replyTo ? [formatEmailAddress(replyTo)] : void 0
+      });
+      const response = await client.send(command);
+      return {
+        success: true,
+        messageId: response.MessageId
+      };
+    } catch (error) {
+      const errorMessage = error.message || "Failed to send email";
+      return {
+        success: false,
+        error: `[ses_error] ${errorMessage}`
+      };
+    }
+  }
+};
+function createSesProviderFromEnv() {
+  const region = process.env.SES_REGION || process.env.AWS_REGION;
+  if (!region) {
+    return null;
+  }
+  return new SesProvider({
+    region,
+    accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
+  });
+}
+
+// src/providers/oci-email.ts
+var OciEmailProvider = class {
+  constructor(config) {
+    this.fromAddress = config.fromAddress;
+    this.smtp = new SmtpProvider({
+      host: config.host,
+      port: config.port,
+      user: config.user,
+      password: config.password,
+      secure: config.port === 465
+    });
+  }
+  isConfigured() {
+    return this.smtp.isConfigured();
+  }
+  async send(params) {
+    const effective = {
+      ...params,
+      from: params.from ?? this.fromAddress
+    };
+    return this.smtp.send(effective);
+  }
+};
+function createOciEmailProviderFromEnv() {
+  const host = process.env.OCI_EMAIL_SMTP_HOST;
+  const user = process.env.OCI_EMAIL_SMTP_USER;
+  const password = process.env.OCI_EMAIL_SMTP_PASS;
+  if (!host || !user || !password) {
+    return null;
+  }
+  const port = parseInt(process.env.OCI_EMAIL_SMTP_PORT || "587", 10);
+  return new OciEmailProvider({
+    host,
+    port,
+    user,
+    password,
+    fromAddress: process.env.OCI_EMAIL_FROM_ADDRESS
+  });
+}
+
+// src/providers/index.ts
+function createProviderFromEnv() {
+  const explicitProvider = process.env.EMAIL_PROVIDER;
+  if (explicitProvider === "smtp") {
+    return createSmtpProviderFromEnv();
+  }
+  if (explicitProvider === "ses") {
+    return createSesProviderFromEnv();
+  }
+  if (explicitProvider === "oci-email") {
+    return createOciEmailProviderFromEnv();
+  }
+  if (process.env.OCI_EMAIL_SMTP_HOST) {
+    return createOciEmailProviderFromEnv();
+  }
+  if (process.env.SMTP_HOST) {
+    return createSmtpProviderFromEnv();
+  }
+  if (process.env.SES_REGION || process.env.AWS_REGION) {
+    return createSesProviderFromEnv();
+  }
+  return null;
+}
+
+// src/server.ts
+var EmailService = class {
+  constructor(provider, templates, defaultFrom) {
+    this.provider = provider;
+    this.templates = templates;
+    this.defaultFrom = defaultFrom;
+  }
+  /**
+   * Check if the service is configured and ready
+   */
+  isConfigured() {
+    return this.provider.isConfigured();
+  }
+  /**
+   * Register a custom email template
+   */
+  registerTemplate(template) {
+    this.templates.register(template);
+  }
+  /**
+   * Send a raw email
+   */
+  async send(params) {
+    const emailParams = {
+      ...params,
+      from: params.from ?? this.defaultFrom
+    };
+    return this.provider.send(emailParams);
+  }
+  /**
+   * Send a templated email
+   */
+  async sendTemplate(params) {
+    const { template: templateName, data, ...rest } = params;
+    const { subject, html, text } = this.templates.render(templateName, data);
+    return this.send({
+      ...rest,
+      subject,
+      html,
+      text
+    });
+  }
+};
+function createEmail(options = {}) {
+  const { config, defaultFrom, includeBuiltins = true } = options;
+  let provider = null;
+  if (config) {
+    if (config.provider === "smtp" && config.smtp) {
+      provider = new SmtpProvider(config.smtp);
+    } else if (config.provider === "ses" && config.ses) {
+      provider = new SesProvider(config.ses);
+    } else if (config.provider === "oci-email" && config.ociEmail) {
+      provider = new OciEmailProvider(config.ociEmail);
+    }
+  } else {
+    provider = createProviderFromEnv();
+  }
+  if (!provider) {
+    throw EmailError.providerNotConfigured();
+  }
+  const from = defaultFrom ?? config?.defaultFrom ?? process.env.EMAIL_FROM ?? process.env.SMTP_FROM_EMAIL ?? process.env.SES_FROM_EMAIL ?? process.env.OCI_EMAIL_FROM_ADDRESS;
+  if (!from) {
+    throw EmailError.configMissing("defaultFrom (or EMAIL_FROM env var)");
+  }
+  const templates = includeBuiltins ? createShogoTemplateRegistry() : new EmailTemplateRegistry();
+  return new EmailService(provider, templates, from);
+}
+function createEmailOptional(options = {}) {
+  try {
+    return createEmail(options);
+  } catch {
+    return null;
+  }
+}
+export {
+  createEmail,
+  createEmailOptional
+};
+//# sourceMappingURL=server.js.map