@gravito/signal 1.0.0-alpha.2

package/src/transports/MemoryTransport.ts

@@ -0,0 +1,11 @@
+import type { DevMailbox } from '../dev/DevMailbox'
+import type { Message, Transport } from '../types'
+
+export class MemoryTransport implements Transport {
+  constructor(private mailbox: DevMailbox) {}
+
+  async send(message: Message): Promise<void> {
+    this.mailbox.add(message)
+    // console.log(`[MemoryTransport] Email stored in DevMailbox for: ${message.to.map(t => t.address).join(', ')}`);
+  }
+}

package/src/transports/SesTransport.ts

@@ -0,0 +1,56 @@
+import { SESClient, SendRawEmailCommand } from '@aws-sdk/client-ses'
+import nodemailer from 'nodemailer'
+import type { Address, Message, Transport } from '../types'
+
+export interface SesConfig {
+  region: string
+  accessKeyId?: string
+  secretAccessKey?: string
+}
+
+export class SesTransport implements Transport {
+  private transporter: nodemailer.Transporter
+
+  constructor(config: SesConfig) {
+    const clientConfig: any = { region: config.region }
+
+    if (config.accessKeyId && config.secretAccessKey) {
+      clientConfig.credentials = {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      }
+    }
+
+    const ses = new SESClient(clientConfig)
+
+    this.transporter = nodemailer.createTransport({
+      SES: { ses, aws: { SendRawEmailCommand } },
+    } as any)
+  }
+
+  async send(message: Message): Promise<void> {
+    await this.transporter.sendMail({
+      from: this.formatAddress(message.from),
+      to: message.to.map(this.formatAddress),
+      cc: message.cc?.map(this.formatAddress),
+      bcc: message.bcc?.map(this.formatAddress),
+      replyTo: message.replyTo ? this.formatAddress(message.replyTo) : undefined,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      headers: message.headers,
+      priority: message.priority,
+      attachments: message.attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        contentType: a.contentType,
+        cid: a.cid,
+        encoding: a.encoding,
+      })),
+    })
+  }
+
+  private formatAddress(addr: Address): string {
+    return addr.name ? `"${addr.name}" <${addr.address}>` : addr.address
+  }
+}

package/src/transports/SmtpTransport.ts

@@ -0,0 +1,50 @@
+import nodemailer from 'nodemailer'
+import type { Address, Message, Transport } from '../types'
+
+export interface SmtpConfig {
+  host: string
+  port: number
+  secure?: boolean
+  auth?: {
+    user: string
+    pass: string
+  }
+  tls?: {
+    rejectUnauthorized?: boolean
+    ciphers?: string
+  }
+}
+
+export class SmtpTransport implements Transport {
+  private transporter: nodemailer.Transporter
+
+  constructor(config: SmtpConfig) {
+    this.transporter = nodemailer.createTransport(config)
+  }
+
+  async send(message: Message): Promise<void> {
+    await this.transporter.sendMail({
+      from: this.formatAddress(message.from),
+      to: message.to.map(this.formatAddress),
+      cc: message.cc?.map(this.formatAddress),
+      bcc: message.bcc?.map(this.formatAddress),
+      replyTo: message.replyTo ? this.formatAddress(message.replyTo) : undefined,
+      subject: message.subject,
+      html: message.html,
+      text: message.text,
+      headers: message.headers,
+      priority: message.priority,
+      attachments: message.attachments?.map((a) => ({
+        filename: a.filename,
+        content: a.content,
+        contentType: a.contentType,
+        cid: a.cid,
+        encoding: a.encoding,
+      })),
+    })
+  }
+
+  private formatAddress(addr: Address): string {
+    return addr.name ? `"${addr.name}" <${addr.address}>` : addr.address
+  }
+}

package/src/transports/Transport.ts

@@ -0,0 +1,8 @@
+import type { Message } from '../types'
+
+export interface Transport {
+  /**
+   * Send the given message
+   */
+  send(message: Message): Promise<void>
+}

package/src/types.ts

@@ -0,0 +1,71 @@
+import type { Transport } from './transports/Transport'
+export type { Transport }
+
+export interface Address {
+  name?: string
+  address: string
+}
+
+export interface Attachment {
+  filename: string
+  content: string | Buffer // Buffer for Node.js
+  contentType?: string
+  cid?: string // Content-ID for inline images
+  encoding?: string
+}
+
+export interface Envelope {
+  from?: Address | undefined
+  to?: Address[] | undefined
+  cc?: Address[] | undefined
+  bcc?: Address[] | undefined
+  replyTo?: Address | undefined
+  subject?: string | undefined
+  priority?: 'high' | 'normal' | 'low' | undefined
+  attachments?: Attachment[] | undefined
+}
+
+export interface Message extends Envelope {
+  from: Address // From is required in finalized message
+  to: Address[] // To is required in finalized message
+  subject: string
+  html: string // The rendered HTML content
+  text?: string // The rendered plain text content
+  headers?: Record<string, string>
+}
+
+export interface MailConfig {
+  /**
+   * Default sender address
+   */
+  from?: Address
+
+  /**
+   * The transport mechanism used to send emails
+   */
+  transport?: Transport
+
+  /**
+   * Enable development mode (intercepts emails)
+   */
+  devMode?: boolean | undefined
+
+  /**
+   * Directory where email templates are located (for OrbitPrism)
+   * Default: src/emails
+   */
+  viewsDir?: string | undefined
+
+  /**
+   * URL prefix for Dev UI
+   * Default: /__mail
+   */
+  devUiPrefix?: string | undefined
+
+  /**
+   * Translation function for i18n support
+   */
+  translator?:
+    | ((key: string, replace?: Record<string, unknown>, locale?: string) => string)
+    | undefined
+}

package/tests/mailable.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'bun:test'
+import { Mailable } from '../src/Mailable'
+import { OrbitSignal } from '../src/OrbitSignal'
+import { LogTransport } from '../src/transports/LogTransport'
+import type { Message, Transport } from '../src/transports/Transport'
+
+// Mock Transport
+class MockTransport implements Transport {
+  public sentMessages: Message[] = []
+  async send(message: Message): Promise<void> {
+    this.sentMessages.push(message)
+  }
+}
+
+// Example Mailable
+class WelcomeMail extends Mailable {
+  constructor(private name: string) {
+    super()
+  }
+
+  build() {
+    return this.subject('Welcome!').html(`<h1>Welcome, ${this.name}</h1>`)
+  }
+}
+
+describe('OrbitSignal Core', () => {
+  it('should send a simple email via transport', async () => {
+    const transport = new MockTransport()
+
+    const mailer = OrbitSignal.configure({
+      from: { name: 'System', address: 'system@example.com' },
+      transport: transport,
+    })
+
+    const mail = new WelcomeMail('Carl').to('carl@example.com')
+
+    await mailer.send(mail)
+
+    expect(transport.sentMessages.length).toBe(1)
+    const msg = transport.sentMessages[0]
+
+    expect(msg.to[0].address).toBe('carl@example.com')
+    expect(msg.subject).toBe('Welcome!')
+    expect(msg.html).toBe('<h1>Welcome, Carl</h1>')
+    expect(msg.from.address).toBe('system@example.com')
+  })
+
+  it('should handle fluent API correctly', async () => {
+    const mail = new WelcomeMail('Carl')
+      .to(['a@b.com', { address: 'c@d.com', name: 'C' }])
+      .cc('cc@example.com')
+      .priority('high')
+
+    const config = {
+      from: { address: 'default@example.com' },
+      transport: new LogTransport(),
+    }
+
+    const envelope = await mail.buildEnvelope(config)
+
+    expect(envelope.to).toHaveLength(2)
+    expect(envelope.cc).toHaveLength(1)
+    expect(envelope.priority).toBe('high')
+    expect(envelope.from?.address).toBe('default@example.com')
+  })
+
+  it('should throw error if renderer is missing', async () => {
+    class EmptyMail extends Mailable {
+      build() {
+        return this
+      }
+    }
+
+    const mail = new EmptyMail()
+    expect(mail.renderContent()).rejects.toThrow('No content renderer')
+  })
+})

package/tests/renderers.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test'
+import { createElement } from 'react'
+import { defineComponent, h } from 'vue'
+import { Mailable } from '../src/Mailable'
+import { LogTransport } from '../src/transports/LogTransport'
+
+// Mock Config for Mailable
+const mockConfig = {
+  from: { address: 'test@example.com' },
+  transport: new LogTransport(),
+}
+
+// React Component
+const ReactTestComponent = ({ name }: { name: string }) => {
+  return createElement('div', {}, createElement('h1', {}, `Hello ${name}`))
+}
+
+// Vue Component
+const VueTestComponent = defineComponent({
+  props: ['name'],
+  render() {
+    return h('div', [h('h1', `Hello ${this.name}`)])
+  },
+})
+
+class TestReactMail extends Mailable {
+  build() {
+    return this.react(ReactTestComponent, { name: 'World' }).subject('React Test')
+  }
+}
+
+class TestVueMail extends Mailable {
+  build() {
+    return this.vue(VueTestComponent, { name: 'World' }).subject('Vue Test')
+  }
+}
+
+describe('Renderers', () => {
+  it('should render React component to HTML', async () => {
+    const mail = new TestReactMail()
+    const _envelope = await mail.buildEnvelope(mockConfig)
+    const { html } = await mail.renderContent()
+
+    expect(html).toContain('<!DOCTYPE html>')
+    expect(html).toContain('<h1>Hello World</h1>')
+  })
+
+  it('should render Vue component to HTML', async () => {
+    const mail = new TestVueMail()
+    const _envelope = await mail.buildEnvelope(mockConfig)
+    const { html } = await mail.renderContent()
+
+    expect(html).toContain('<!DOCTYPE html>')
+    expect(html).toContain('<h1>Hello World</h1>')
+  })
+})

package/tests/transports.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'bun:test'
+import { DevMailbox } from '../src/dev/DevMailbox'
+import { MemoryTransport } from '../src/transports/MemoryTransport'
+import type { Message } from '../src/types'
+
+describe('Transports', () => {
+  describe('MemoryTransport & DevMailbox', () => {
+    it('should store sent emails in mailbox', async () => {
+      const mailbox = new DevMailbox()
+      const transport = new MemoryTransport(mailbox)
+
+      const message: Message = {
+        from: { address: 'from@example.com' },
+        to: [{ address: 'to@example.com' }],
+        subject: 'Test Subject',
+        html: '<p>Content</p>',
+        priority: 'normal',
+      }
+
+      await transport.send(message)
+
+      const entries = mailbox.list()
+      expect(entries).toHaveLength(1)
+
+      const entry = entries[0]
+      expect(entry.envelope.subject).toBe('Test Subject')
+      expect(entry.html).toBe('<p>Content</p>')
+      expect(entry.sentAt).toBeInstanceOf(Date)
+    })
+
+    it('should limit mailbox size', async () => {
+      const mailbox = new DevMailbox()
+      // Hack: set max entries lower for test if possible, or just add 51 entries
+      // Since maxEntries is private, we just add 51
+      const transport = new MemoryTransport(mailbox)
+
+      for (let i = 0; i < 60; i++) {
+        await transport.send({
+          from: { address: 'a@b.com' },
+          to: [{ address: 'b@c.com' }],
+          subject: `Msg ${i}`,
+          html: 'content',
+          priority: 'normal',
+        })
+      }
+
+      expect(mailbox.list().length).toBeLessThanOrEqual(50)
+      // Should be the latest ones (last one added is index 0)
+      expect(mailbox.list()[0].envelope.subject).toBe('Msg 59')
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "baseUrl": ".",
+        "paths": {
+            "gravito-core": ["../../packages/core/src/index.ts"],
+            "@gravito/*": ["../../packages/*/src/index.ts"]
+        }
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist",
+        "**/*.test.ts"
+    ]
+}