@stacksjs/email 0.69.3 → 0.70.1

package/dist/mailgun.d.ts

@@ -0,0 +1,141 @@
+import type { EmailAddress, EmailMessage, EmailResult, RenderOptions } from '@stacksjs/types';
+
+export declare class MailgunDriver extends BaseEmailDriver {
+  public name = 'mailgun'
+  private apiKey: string
+  private domain: string
+  private endpoint: string
+
+  constructor() {
+    super()
+    this.apiKey = config.services.mailgun?.apiKey ?? ''
+    this.domain = config.services.mailgun?.domain ?? ''
+    this.endpoint = config.services.mailgun?.endpoint ?? 'api.mailgun.net'
+  }
+
+  public async send(message: EmailMessage, options?: RenderOptions): Promise<EmailResult> {
+    const logContext = {
+      provider: this.name,
+      to: message.to,
+      subject: message.subject,
+      domain: this.domain,
+    }
+
+    log.info('Sending email via Mailgun...', logContext)
+
+    try {
+      this.validateMessage(message)
+
+      let htmlContent: string | undefined
+      if (message.template) {
+        const templ = await template(message.template, options)
+        if (templ && 'html' in templ) {
+          htmlContent = templ.html
+        }
+      }
+
+      const formData = new FormData()
+      formData.append('from', this.formatMailgunAddress(message.from))
+
+      this.formatMailgunAddresses(message.to).forEach(to => formData.append('to', to))
+
+      if (message.cc)
+        this.formatMailgunAddresses(message.cc).forEach(cc => formData.append('cc', cc))
+
+      if (message.bcc)
+        this.formatMailgunAddresses(message.bcc).forEach(bcc => formData.append('bcc', bcc))
+
+      formData.append('subject', message.subject)
+
+      if (htmlContent) {
+        formData.append('html', htmlContent)
+      }
+
+      if (message.text)
+        formData.append('text', message.text)
+
+      if (message.attachments) {
+        message.attachments.forEach((attachment) => {
+          const content = typeof attachment.content === 'string'
+            ? attachment.content
+            : this.arrayBufferToBase64(attachment.content)
+
+          formData.append('attachment', new Blob([content], { type: attachment.contentType }), attachment.filename)
+        })
+      }
+
+      const response = await this.sendWithRetry(formData)
+      return this.handleSuccess(message, response.id)
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+  }
+
+  private formatMailgunAddress(address: EmailAddress): string {
+    return address.name ? `${address.name} <${address.address}>` : address.address
+  }
+
+  private formatMailgunAddresses(addresses: string | string[] | EmailAddress[] | undefined): string[] {
+    if (!addresses)
+      return []
+
+    if (typeof addresses === 'string')
+      return [addresses]
+
+    return addresses.map((addr) => {
+      if (typeof addr === 'string')
+        return addr
+      return addr.name ? `${addr.name} <${addr.address}>` : addr.address
+    })
+  }
+
+  private arrayBufferToBase64(buffer: Uint8Array): string {
+    let binary = ''
+    const bytes = new Uint8Array(buffer)
+    const len = bytes.byteLength
+
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i])
+    }
+
+    return typeof btoa === 'function'
+      ? btoa(binary)
+      : Buffer.from(binary).toString('base64')
+  }
+
+  private async sendWithRetry(formData: FormData, attempt = 1): Promise<any> {
+    const url = `https:
+    const auth = Buffer.from(`api:${this.apiKey}`).toString('base64')
+
+    try {
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Basic ${auth}`,
+        },
+        body: formData,
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json()
+        throw new Error(`Mailgun API error: ${response.status} - ${JSON.stringify(errorData)}`)
+      }
+
+      const data = await response.json()
+      log.info(`[${this.name}] Email sent successfully`, { attempt, messageId: data.id })
+      return data
+    }
+    catch (error) {
+      if (attempt < (config.services.mailgun?.maxRetries ?? 3)) {
+        const retryTimeout = config.services.mailgun?.retryTimeout ?? 1000
+        log.warn(`[${this.name}] Email send failed, retrying (${attempt}/${config.services.mailgun?.maxRetries ?? 3})`)
+        await new Promise(resolve => setTimeout(resolve, retryTimeout))
+        return this.sendWithRetry(formData, attempt + 1)
+      }
+      throw error
+    }
+  }
+}
+
+export default MailgunDriver;

package/dist/mailtrap.d.ts

@@ -0,0 +1,131 @@
+import type { EmailMessage, EmailResult, MailtrapResponse, RenderOptions } from '@stacksjs/types';
+
+export declare class MailtrapDriver extends BaseEmailDriver {
+  public name = 'mailtrap'
+  private host: string
+  private token: string
+  private inboxId?: number
+
+  constructor() {
+    super()
+    this.host = config.services.mailtrap?.host ?? 'https:
+    this.token = config.services.mailtrap?.token ?? ''
+    this.inboxId = config.services.mailtrap?.inboxId ? Number(config.services.mailtrap.inboxId) : undefined
+  }
+
+  public async send(message: EmailMessage, options?: RenderOptions): Promise<EmailResult> {
+    const logContext = {
+      provider: this.name,
+      to: message.to,
+      subject: message.subject,
+      inboxId: this.inboxId,
+    }
+
+    log.info('Sending email via Mailtrap...', logContext)
+
+    try {
+      this.validateMessage(message)
+      let templ
+      if (message.template)
+        templ = await template(message.template, options)
+
+      const mailtrapPayload = {
+        from: {
+          email: message.from.address || config.email.from?.address,
+          ...(message.from.name && { name: message.from.name }),
+        },
+        to: this.formatMailtrapAddresses(message.to),
+        ...(message.cc && { cc: this.formatMailtrapAddresses(message.cc) }),
+        ...(message.bcc && { bcc: this.formatMailtrapAddresses(message.bcc) }),
+        subject: message.subject,
+        ...(templ?.html && { html: templ.html }),
+        ...(message.text && { text: message.text }),
+        ...(message.attachments && {
+          attachments: message.attachments.map(attachment => ({
+            filename: attachment.filename,
+            content: typeof attachment.content === 'string'
+              ? attachment.content
+              : this.arrayBufferToBase64(attachment.content),
+            type: attachment.contentType || 'application/octet-stream',
+          })),
+        }),
+      }
+
+      const response = await this.sendWithRetry(mailtrapPayload)
+      return this.handleSuccess(message, response.message_ids?.[0])
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+  }
+
+  private formatMailtrapAddresses(addresses: string | string[] | EmailAddress[] | undefined): Array<{ email: string, name?: string }> {
+    if (!addresses)
+      return []
+
+    if (typeof addresses === 'string') {
+      return [{ email: addresses }]
+    }
+
+    return addresses.map((addr) => {
+      if (typeof addr === 'string')
+        return { email: addr }
+      return { email: addr.address, ...(addr.name && { name: addr.name }) }
+    })
+  }
+
+  private arrayBufferToBase64(buffer: Uint8Array): string {
+    let binary = ''
+    const bytes = new Uint8Array(buffer)
+    const len = bytes.byteLength
+
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i])
+    }
+
+    return typeof btoa === 'function'
+      ? btoa(binary)
+      : Buffer.from(binary).toString('base64')
+  }
+
+  private async sendWithRetry(payload: any, attempt = 1): Promise<any> {
+    if (!this.inboxId) {
+      throw new Error('Mailtrap inbox ID is required but not provided. Please set MAILTRAP_INBOX_ID in your environment variables.')
+    }
+
+    const endpoint = `${this.host}/${this.inboxId}`
+
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.token}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json()
+        throw new Error(`Mailtrap API error: ${response.status} - ${JSON.stringify(errorData)}`)
+      }
+
+      const data: MailtrapResponse = await (response.json() as Promise<MailtrapResponse>)
+
+      log.info(`[${this.name}] Email sent successfully`, { attempt, messageId: data.message_ids?.[0] })
+      return data
+    }
+    catch (error) {
+      if (attempt < (config.services.mailtrap?.maxRetries ?? 3)) {
+        const retryTimeout = config.services.mailtrap?.retryTimeout ?? 1000
+        log.warn(`[${this.name}] Email send failed, retrying (${attempt}/${config.services.mailtrap?.maxRetries ?? 3})`)
+        await new Promise(resolve => setTimeout(resolve, retryTimeout))
+
+        return this.sendWithRetry(payload, attempt + 1)
+      }
+      throw error
+    }
+  }
+}
+
+export default MailtrapDriver;

package/dist/sendgrid.d.ts

@@ -0,0 +1,146 @@
+import type { EmailMessage, EmailResult, RenderOptions } from '@stacksjs/types';
+
+export declare class SendGridDriver extends BaseEmailDriver {
+  public name = 'sendgrid'
+  private apiKey: string
+
+  constructor() {
+    super()
+    this.apiKey = config.services.sendgrid?.apiKey ?? ''
+  }
+
+  public async send(message: EmailMessage, options?: RenderOptions): Promise<EmailResult> {
+    const logContext = {
+      provider: this.name,
+      to: message.to,
+      subject: message.subject,
+    }
+
+    log.info('Sending email via SendGrid...', logContext)
+
+    try {
+      this.validateMessage(message)
+
+      let htmlContent: string | undefined
+      if (message.template) {
+        const templ = await template(message.template, options)
+        if (templ && 'html' in templ) {
+          htmlContent = templ.html
+        }
+      }
+
+      const content = []
+
+      if (htmlContent) {
+        content.push({
+          type: 'text/html',
+          value: htmlContent,
+        })
+      }
+
+      if (message.text) {
+        content.push({
+          type: 'text/plain',
+          value: message.text,
+        })
+      }
+
+      if (content.length === 0) {
+        throw new Error('Email must have either HTML or text content')
+      }
+
+      const sendgridPayload = {
+        personalizations: [
+          {
+            to: this.formatSendGridAddresses(message.to),
+            ...(message.cc && { cc: this.formatSendGridAddresses(message.cc) }),
+            ...(message.bcc && { bcc: this.formatSendGridAddresses(message.bcc) }),
+            subject: message.subject,
+          },
+        ],
+        from: {
+          email: message.from.address || config.email.from?.address,
+          ...(message.from.name && { name: message.from.name }),
+        },
+        content,
+        ...(message.attachments && {
+          attachments: message.attachments.map(attachment => ({
+            filename: attachment.filename,
+            content: typeof attachment.content === 'string'
+              ? attachment.content
+              : this.arrayBufferToBase64(attachment.content),
+            type: attachment.contentType,
+            disposition: 'attachment',
+          })),
+        }),
+      }
+
+      const response = await this.sendWithRetry(sendgridPayload)
+      return this.handleSuccess(message, response.headers?.['x-message-id'])
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+  }
+
+  private formatSendGridAddresses(addresses: string | string[] | EmailAddress[] | undefined): Array<{ email: string, name?: string }> {
+    if (!addresses)
+      return []
+
+    if (typeof addresses === 'string') {
+      return [{ email: addresses }]
+    }
+
+    return addresses.map((addr) => {
+      if (typeof addr === 'string')
+        return { email: addr }
+      return { email: addr.address, ...(addr.name && { name: addr.name }) }
+    })
+  }
+
+  private arrayBufferToBase64(buffer: Uint8Array): string {
+    let binary = ''
+    const bytes = new Uint8Array(buffer)
+    const len = bytes.byteLength
+
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i])
+    }
+
+    return typeof btoa === 'function'
+      ? btoa(binary)
+      : Buffer.from(binary).toString('base64')
+  }
+
+  private async sendWithRetry(payload: any, attempt = 1): Promise<any> {
+    try {
+      const response = await fetch('https:
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this.apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+      })
+
+      if (!response.ok) {
+        const errorData = await response.json()
+        throw new Error(`SendGrid API error: ${response.status} - ${JSON.stringify(errorData)}`)
+      }
+
+      log.info(`[${this.name}] Email sent successfully`, { attempt })
+      return response
+    }
+    catch (error) {
+      if (attempt < (config.services.sendgrid?.maxRetries ?? 3)) {
+        const retryTimeout = config.services.sendgrid?.retryTimeout ?? 1000
+        log.warn(`[${this.name}] Email send failed, retrying (${attempt}/${config.services.sendgrid?.maxRetries ?? 3})`)
+        await new Promise(resolve => setTimeout(resolve, retryTimeout))
+        return this.sendWithRetry(payload, attempt + 1)
+      }
+      throw error
+    }
+  }
+}
+
+export default SendGridDriver;

package/dist/ses.d.ts

@@ -0,0 +1,80 @@
+import type { EmailMessage, EmailResult, RenderOptions } from '@stacksjs/types';
+
+export declare class SESDriver extends BaseEmailDriver {
+  public name = 'ses'
+  private client: SES
+
+  constructor() {
+    super()
+
+    const credentials = {
+      accessKeyId: config.services.ses?.credentials?.accessKeyId ?? '',
+      secretAccessKey: config.services.ses?.credentials?.secretAccessKey ?? '',
+    }
+
+    this.client = new SES({
+      region: config.services.ses?.region || 'us-east-1',
+      credentials,
+    })
+  }
+
+  public async send(message: EmailMessage, options?: RenderOptions): Promise<EmailResult> {
+    try {
+      this.validateMessage(message)
+
+      let htmlContent: string | undefined
+      if (message.template) {
+        const templ = await template(message.template, options)
+        if (templ && 'html' in templ) {
+          htmlContent = templ.html
+        }
+      }
+
+      const messageBody: any = {}
+
+      if (htmlContent) {
+        messageBody.Html = {
+          Charset: config.email.charset || 'UTF-8',
+          Data: htmlContent,
+        }
+      }
+
+      if (message.text) {
+        messageBody.Text = {
+          Charset: config.email.charset || 'UTF-8',
+          Data: message.text,
+        }
+      }
+
+      if (Object.keys(messageBody).length === 0) {
+        throw new Error('Email must have either HTML or text content')
+      }
+
+      const params = {
+        Source: message.from?.address || config.email.from?.address,
+
+        Destination: {
+          ToAddresses: this.formatAddresses(message.to),
+          CcAddresses: this.formatAddresses(message.cc),
+          BccAddresses: this.formatAddresses(message.bcc),
+        },
+
+        Message: {
+          Body: messageBody,
+          Subject: {
+            Charset: config.email.charset || 'UTF-8',
+            Data: message.subject,
+          },
+        },
+      }
+
+      const response = await this.client.send(new SendEmailCommand(params))
+      return this.handleSuccess(message, response.MessageId)
+    }
+    catch (error) {
+      return this.handleError(error, message)
+    }
+  }
+}
+
+export default SESDriver;

package/dist/template.d.ts

@@ -1,7 +1,7 @@
-import type { I18n } from 'vue-email';
+import type { RenderOptions } from '@stacksjs/types';
 
-export declare interface RenderOptions {
-  props?: Record<string, unknown>
-  i18n?: I18n
+declare interface HtmlResult {
+  html: string
+  text: string
 }
-export declare function template(path: string, options?: RenderOptions): Promise<string>;
+export declare function template(path: string, options?: RenderOptions): Promise<HtmlResult>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@stacksjs/email",
   "type": "module",
-  "version": "0.69.3",
+  "version": "0.70.1",
   "description": "The Stacks Email integration. Painlessly create & manage your inboxes, templates, and send emails.",
   "author": "Chris Breuer",
   "contributors": ["Chris Breuer <chris@stacksjs.org>"],
@@ -35,11 +35,11 @@
     "prepublishOnly": "bun run build"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.69.2",
-    "@stacksjs/config": "0.69.2",
-    "@stacksjs/development": "0.69.2",
-    "@stacksjs/error-handling": "0.69.2",
-    "@stacksjs/types": "0.69.2",
+    "@stacksjs/cli": "0.70.1",
+    "@stacksjs/config": "0.70.1",
+    "@stacksjs/development": "0.70.1",
+    "@stacksjs/error-handling": "0.70.1",
+    "@stacksjs/types": "0.70.1",
     "aws-sdk": "^2.1692.0",
     "vue-email": "^0.8.11"
   }