@mantiq/mail 0.1.3 → 0.2.0

package/src/drivers/PostmarkTransport.ts

@@ -0,0 +1,89 @@
+import type { MailTransport } from '../contracts/Transport.ts'
+import { Message } from '../Message.ts'
+import { MailError } from '../errors/MailError.ts'
+
+export interface PostmarkConfig {
+  serverToken: string
+}
+
+export class PostmarkTransport implements MailTransport {
+  private config: PostmarkConfig
+
+  constructor(config: PostmarkConfig) {
+    this.config = config
+  }
+
+  async send(message: Message): Promise<{ id: string }> {
+    const body: Record<string, any> = {
+      From: Message.formatAddress(message.from),
+      To: Message.formatAddresses(message.to),
+      Subject: message.subject,
+    }
+
+    if (message.cc.length > 0) {
+      body.Cc = Message.formatAddresses(message.cc)
+    }
+
+    if (message.bcc.length > 0) {
+      body.Bcc = Message.formatAddresses(message.bcc)
+    }
+
+    if (message.replyTo.length > 0) {
+      body.ReplyTo = Message.formatAddresses(message.replyTo)
+    }
+
+    if (message.html !== null) {
+      body.HtmlBody = message.html
+    }
+
+    if (message.text !== null) {
+      body.TextBody = message.text
+    }
+
+    if (message.attachments.length > 0) {
+      body.Attachments = message.attachments.map((attachment) => ({
+        Name: attachment.filename,
+        Content: typeof attachment.content === 'string'
+          ? Buffer.from(attachment.content).toString('base64')
+          : Buffer.from(attachment.content).toString('base64'),
+        ContentType: attachment.contentType || 'application/octet-stream',
+      }))
+    }
+
+    // Custom headers
+    if (Object.keys(message.headers).length > 0) {
+      body.Headers = Object.entries(message.headers).map(([Name, Value]) => ({
+        Name,
+        Value,
+      }))
+    }
+
+    const response = await fetch('https://api.postmarkapp.com/email', {
+      method: 'POST',
+      headers: {
+        'X-Postmark-Server-Token': this.config.serverToken,
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text()
+      throw new MailError(`Postmark API error: ${response.status} ${response.statusText}`, {
+        status: response.status,
+        body: errorBody,
+      })
+    }
+
+    const result = await response.json() as { MessageID: string; ErrorCode: number; Message: string }
+
+    if (result.ErrorCode !== 0) {
+      throw new MailError(`Postmark error: ${result.Message}`, {
+        errorCode: result.ErrorCode,
+      })
+    }
+
+    return { id: result.MessageID }
+  }
+}

package/src/drivers/ResendTransport.ts

@@ -0,0 +1,78 @@
+import type { MailTransport } from '../contracts/Transport.ts'
+import { Message } from '../Message.ts'
+import { MailError } from '../errors/MailError.ts'
+
+export interface ResendConfig {
+  apiKey: string
+}
+
+export class ResendTransport implements MailTransport {
+  private config: ResendConfig
+
+  constructor(config: ResendConfig) {
+    this.config = config
+  }
+
+  async send(message: Message): Promise<{ id: string }> {
+    const body: Record<string, any> = {
+      from: Message.formatAddress(message.from),
+      to: message.to.map((addr) => Message.formatAddress(addr)),
+      subject: message.subject,
+    }
+
+    if (message.cc.length > 0) {
+      body.cc = message.cc.map((addr) => Message.formatAddress(addr))
+    }
+
+    if (message.bcc.length > 0) {
+      body.bcc = message.bcc.map((addr) => Message.formatAddress(addr))
+    }
+
+    if (message.replyTo.length > 0) {
+      body.reply_to = message.replyTo.map((addr) => Message.formatAddress(addr))
+    }
+
+    if (message.html !== null) {
+      body.html = message.html
+    }
+
+    if (message.text !== null) {
+      body.text = message.text
+    }
+
+    if (message.attachments.length > 0) {
+      body.attachments = message.attachments.map((attachment) => ({
+        filename: attachment.filename,
+        content: typeof attachment.content === 'string'
+          ? Buffer.from(attachment.content).toString('base64')
+          : Buffer.from(attachment.content).toString('base64'),
+        type: attachment.contentType || 'application/octet-stream',
+      }))
+    }
+
+    if (Object.keys(message.headers).length > 0) {
+      body.headers = message.headers
+    }
+
+    const response = await fetch('https://api.resend.com/emails', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text()
+      throw new MailError(`Resend API error: ${response.status} ${response.statusText}`, {
+        status: response.status,
+        body: errorBody,
+      })
+    }
+
+    const result = await response.json() as { id: string }
+
+    return { id: result.id }
+  }
+}

package/src/drivers/SendGridTransport.ts

@@ -0,0 +1,102 @@
+import type { MailTransport } from '../contracts/Transport.ts'
+import { Message } from '../Message.ts'
+import type { MailAddress } from '../contracts/MailConfig.ts'
+import { MailError } from '../errors/MailError.ts'
+
+export interface SendGridConfig {
+  apiKey: string
+}
+
+export class SendGridTransport implements MailTransport {
+  private config: SendGridConfig
+
+  constructor(config: SendGridConfig) {
+    this.config = config
+  }
+
+  async send(message: Message): Promise<{ id: string }> {
+    const personalizations: Record<string, any> = {}
+
+    personalizations.to = message.to.map((addr) => this.formatAddr(addr))
+
+    if (message.cc.length > 0) {
+      personalizations.cc = message.cc.map((addr) => this.formatAddr(addr))
+    }
+
+    if (message.bcc.length > 0) {
+      personalizations.bcc = message.bcc.map((addr) => this.formatAddr(addr))
+    }
+
+    const body: Record<string, any> = {
+      personalizations: [personalizations],
+      from: this.formatAddr(message.from),
+      subject: message.subject,
+    }
+
+    if (message.replyTo.length > 0) {
+      const first = message.replyTo[0]
+      if (first) {
+        body.reply_to = this.formatAddr(first)
+      }
+      if (message.replyTo.length > 1) {
+        body.reply_to_list = message.replyTo.map((addr) => this.formatAddr(addr))
+      }
+    }
+
+    const content: { type: string; value: string }[] = []
+    if (message.text !== null) {
+      content.push({ type: 'text/plain', value: message.text })
+    }
+    if (message.html !== null) {
+      content.push({ type: 'text/html', value: message.html })
+    }
+    if (content.length > 0) {
+      body.content = content
+    }
+
+    if (message.attachments.length > 0) {
+      body.attachments = message.attachments.map((attachment) => ({
+        filename: attachment.filename,
+        content: typeof attachment.content === 'string'
+          ? Buffer.from(attachment.content).toString('base64')
+          : Buffer.from(attachment.content).toString('base64'),
+        type: attachment.contentType || 'application/octet-stream',
+        disposition: 'attachment',
+      }))
+    }
+
+    if (Object.keys(message.headers).length > 0) {
+      body.headers = message.headers
+    }
+
+    const response = await fetch('https://api.sendgrid.com/v3/mail/send', {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(body),
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text()
+      throw new MailError(`SendGrid API error: ${response.status} ${response.statusText}`, {
+        status: response.status,
+        body: errorBody,
+      })
+    }
+
+    // SendGrid returns the message ID in the x-message-id header
+    const messageId = response.headers.get('x-message-id')
+
+    return { id: messageId || crypto.randomUUID() }
+  }
+
+  private formatAddr(addr: MailAddress): { email: string; name?: string } {
+    const result: { email: string; name?: string } = { email: addr.address }
+    if (addr.name) {
+      result.name = addr.name
+    }
+    return result
+  }
+}

package/src/drivers/SesTransport.ts

@@ -0,0 +1,182 @@
+import type { MailTransport } from '../contracts/Transport.ts'
+import { Message } from '../Message.ts'
+import { MailError } from '../errors/MailError.ts'
+
+export interface SesConfig {
+  region: string
+  accessKeyId: string
+  secretAccessKey: string
+}
+
+export class SesTransport implements MailTransport {
+  private config: SesConfig
+
+  constructor(config: SesConfig) {
+    this.config = config
+  }
+
+  async send(message: Message): Promise<{ id: string }> {
+    const { region, accessKeyId, secretAccessKey } = this.config
+    const host = `email.${region}.amazonaws.com`
+    const url = `https://${host}/v2/email/outbound-emails`
+
+    const destination: Record<string, string[]> = {
+      ToAddresses: message.to.map((addr) => Message.formatAddress(addr)),
+    }
+
+    if (message.cc.length > 0) {
+      destination.CcAddresses = message.cc.map((addr) => Message.formatAddress(addr))
+    }
+
+    if (message.bcc.length > 0) {
+      destination.BccAddresses = message.bcc.map((addr) => Message.formatAddress(addr))
+    }
+
+    const bodyContent: Record<string, { Data: string; Charset: string }> = {}
+
+    if (message.html !== null) {
+      bodyContent.Html = { Data: message.html, Charset: 'UTF-8' }
+    }
+
+    if (message.text !== null) {
+      bodyContent.Text = { Data: message.text, Charset: 'UTF-8' }
+    }
+
+    const body: Record<string, any> = {
+      FromEmailAddress: Message.formatAddress(message.from),
+      Destination: destination,
+      Content: {
+        Simple: {
+          Subject: { Data: message.subject, Charset: 'UTF-8' },
+          Body: bodyContent,
+        },
+      },
+    }
+
+    if (message.replyTo.length > 0) {
+      body.ReplyToAddresses = message.replyTo.map((addr) => Message.formatAddress(addr))
+    }
+
+    if (Object.keys(message.headers).length > 0) {
+      body.EmailTags = Object.entries(message.headers).map(([Name, Value]) => ({
+        Name,
+        Value,
+      }))
+    }
+
+    const payload = JSON.stringify(body)
+    const now = new Date()
+
+    // AWS Signature V4
+    const dateStamp = this.toDateStamp(now)
+    const amzDate = this.toAmzDate(now)
+    const service = 'ses'
+    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`
+
+    const canonicalHeaders =
+      `content-type:application/json\n` +
+      `host:${host}\n` +
+      `x-amz-date:${amzDate}\n`
+
+    const signedHeaders = 'content-type;host;x-amz-date'
+
+    const payloadHash = await this.sha256Hex(payload)
+
+    const canonicalRequest = [
+      'POST',
+      '/v2/email/outbound-emails',
+      '', // query string
+      canonicalHeaders,
+      signedHeaders,
+      payloadHash,
+    ].join('\n')
+
+    const canonicalRequestHash = await this.sha256Hex(canonicalRequest)
+
+    const stringToSign = [
+      'AWS4-HMAC-SHA256',
+      amzDate,
+      credentialScope,
+      canonicalRequestHash,
+    ].join('\n')
+
+    // Derive signing key
+    const kDate = await this.hmacSha256(
+      new TextEncoder().encode(`AWS4${secretAccessKey}`),
+      dateStamp,
+    )
+    const kRegion = await this.hmacSha256(kDate, region)
+    const kService = await this.hmacSha256(kRegion, service)
+    const kSigning = await this.hmacSha256(kService, 'aws4_request')
+
+    const signature = await this.hmacSha256Hex(kSigning, stringToSign)
+
+    const authorizationHeader =
+      `AWS4-HMAC-SHA256 ` +
+      `Credential=${accessKeyId}/${credentialScope}, ` +
+      `SignedHeaders=${signedHeaders}, ` +
+      `Signature=${signature}`
+
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Amz-Date': amzDate,
+        'Authorization': authorizationHeader,
+      },
+      body: payload,
+    })
+
+    if (!response.ok) {
+      const errorBody = await response.text()
+      throw new MailError(`AWS SES API error: ${response.status} ${response.statusText}`, {
+        status: response.status,
+        body: errorBody,
+      })
+    }
+
+    const result = await response.json() as { MessageId: string }
+
+    return { id: result.MessageId }
+  }
+
+  private toDateStamp(date: Date): string {
+    return date.toISOString().slice(0, 10).replace(/-/g, '')
+  }
+
+  private toAmzDate(date: Date): string {
+    return date.toISOString().replace(/[-:]/g, '').replace(/\.\d{3}/, '')
+  }
+
+  private async sha256Hex(data: string): Promise<string> {
+    const encoder = new TextEncoder()
+    const hashBuffer = await crypto.subtle.digest('SHA-256', encoder.encode(data))
+    return this.bufferToHex(hashBuffer)
+  }
+
+  private async hmacSha256(key: Uint8Array | ArrayBuffer, data: string): Promise<ArrayBuffer> {
+    const keyBuffer = key instanceof ArrayBuffer ? key : (key as Uint8Array).buffer as ArrayBuffer
+    const cryptoKey = await crypto.subtle.importKey(
+      'raw',
+      keyBuffer,
+      { name: 'HMAC', hash: 'SHA-256' },
+      false,
+      ['sign'],
+    )
+    return await crypto.subtle.sign('HMAC', cryptoKey, new TextEncoder().encode(data))
+  }
+
+  private async hmacSha256Hex(key: Uint8Array | ArrayBuffer, data: string): Promise<string> {
+    const result = await this.hmacSha256(key, data)
+    return this.bufferToHex(result)
+  }
+
+  private bufferToHex(buffer: ArrayBuffer): string {
+    const bytes = new Uint8Array(buffer)
+    let hex = ''
+    for (let i = 0; i < bytes.length; i++) {
+      hex += (bytes[i] as number).toString(16).padStart(2, '0')
+    }
+    return hex
+  }
+}