@guren/server 0.2.0-alpha.7 → 1.0.0-rc.9

package/dist/mail/index.js

@@ -0,0 +1,695 @@
+// src/mail/transports/SmtpTransport.ts
+import nodemailer from "nodemailer";
+function formatAddress(addr) {
+  if (addr.name) {
+    return `"${addr.name}" <${addr.email}>`;
+  }
+  return addr.email;
+}
+var SmtpTransport = class {
+  name = "smtp";
+  // Using any to avoid complex nodemailer type gymnastics
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  transporter;
+  constructor(options) {
+    this.transporter = nodemailer.createTransport({
+      host: options.host,
+      port: options.port ?? 587,
+      secure: options.secure ?? false,
+      auth: options.auth,
+      pool: options.pool ?? true,
+      maxConnections: options.maxConnections ?? 5
+    });
+  }
+  /**
+   * Send an email via SMTP.
+   */
+  async send(message) {
+    try {
+      const mailOptions = {
+        from: message.from ? formatAddress(message.from) : void 0,
+        to: message.to.map(formatAddress).join(", "),
+        cc: message.cc?.map(formatAddress).join(", "),
+        bcc: message.bcc?.map(formatAddress).join(", "),
+        replyTo: message.replyTo ? formatAddress(message.replyTo) : void 0,
+        subject: message.subject,
+        text: message.text,
+        html: message.html,
+        attachments: message.attachments?.map((a) => ({
+          filename: a.filename,
+          content: a.content,
+          path: a.path,
+          contentType: a.contentType,
+          cid: a.cid
+        })),
+        headers: message.headers
+      };
+      const result = await this.transporter.sendMail(mailOptions);
+      return {
+        success: true,
+        messageId: result.messageId,
+        response: result.response
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Verify SMTP connection.
+   */
+  async verify() {
+    try {
+      await this.transporter.verify();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Close the transport.
+   */
+  close() {
+    this.transporter.close();
+  }
+};
+
+// src/mail/transports/ResendTransport.ts
+var ResendTransport = class {
+  name = "resend";
+  apiKey;
+  baseUrl = "https://api.resend.com";
+  constructor(options) {
+    this.apiKey = options.apiKey;
+  }
+  /**
+   * Format email address for Resend API.
+   */
+  formatAddress(addr) {
+    if (addr.name) {
+      return `${addr.name} <${addr.email}>`;
+    }
+    return addr.email;
+  }
+  /**
+   * Send an email via Resend API.
+   */
+  async send(message) {
+    try {
+      const payload = {
+        from: message.from ? this.formatAddress(message.from) : void 0,
+        to: message.to.map((a) => this.formatAddress(a)),
+        subject: message.subject
+      };
+      if (message.cc?.length) {
+        payload.cc = message.cc.map((a) => this.formatAddress(a));
+      }
+      if (message.bcc?.length) {
+        payload.bcc = message.bcc.map((a) => this.formatAddress(a));
+      }
+      if (message.replyTo) {
+        payload.reply_to = this.formatAddress(message.replyTo);
+      }
+      if (message.text) {
+        payload.text = message.text;
+      }
+      if (message.html) {
+        payload.html = message.html;
+      }
+      if (message.attachments?.length) {
+        payload.attachments = message.attachments.map((a) => ({
+          filename: a.filename,
+          content: a.content instanceof Buffer ? a.content.toString("base64") : a.content,
+          content_type: a.contentType
+        }));
+      }
+      if (message.headers) {
+        payload.headers = message.headers;
+      }
+      const response = await fetch(`${this.baseUrl}/emails`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(payload)
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        return {
+          success: false,
+          error: errorData.message || `HTTP ${response.status}`
+        };
+      }
+      const data = await response.json();
+      return {
+        success: true,
+        messageId: data.id,
+        response: `Message sent with ID: ${data.id}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/mail/transports/MemoryTransport.ts
+var MemoryTransport = class {
+  name = "memory";
+  messages = [];
+  simulateFailure;
+  failureMessage;
+  constructor(options = {}) {
+    this.simulateFailure = options.simulateFailure ?? false;
+    this.failureMessage = options.failureMessage ?? "Simulated email failure";
+  }
+  /**
+   * Send an email (stores in memory).
+   */
+  async send(message) {
+    if (this.simulateFailure) {
+      return {
+        success: false,
+        error: this.failureMessage
+      };
+    }
+    const messageId = `memory-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+    this.messages.push({ ...message });
+    return {
+      success: true,
+      messageId,
+      response: "Message stored in memory"
+    };
+  }
+  /**
+   * Get all sent messages.
+   */
+  getMessages() {
+    return [...this.messages];
+  }
+  /**
+   * Get the last sent message.
+   */
+  getLastMessage() {
+    return this.messages[this.messages.length - 1];
+  }
+  /**
+   * Find messages by recipient email.
+   */
+  findByRecipient(email) {
+    return this.messages.filter(
+      (m) => m.to.some((addr) => addr.email.toLowerCase() === email.toLowerCase())
+    );
+  }
+  /**
+   * Find messages by subject.
+   */
+  findBySubject(subject) {
+    return this.messages.filter(
+      (m) => m.subject.toLowerCase().includes(subject.toLowerCase())
+    );
+  }
+  /**
+   * Check if any message was sent to a recipient.
+   */
+  hasSentTo(email) {
+    return this.findByRecipient(email).length > 0;
+  }
+  /**
+   * Check if any message was sent with a subject.
+   */
+  hasSentWithSubject(subject) {
+    return this.findBySubject(subject).length > 0;
+  }
+  /**
+   * Get the count of sent messages.
+   */
+  count() {
+    return this.messages.length;
+  }
+  /**
+   * Clear all stored messages.
+   */
+  clear() {
+    this.messages = [];
+  }
+  /**
+   * Set whether to simulate failures.
+   */
+  setSimulateFailure(simulate, message) {
+    this.simulateFailure = simulate;
+    if (message) {
+      this.failureMessage = message;
+    }
+  }
+  /**
+   * Assert that a message was sent to a recipient.
+   * Throws if no message was found.
+   */
+  assertSentTo(email) {
+    if (!this.hasSentTo(email)) {
+      throw new Error(`No email was sent to ${email}`);
+    }
+  }
+  /**
+   * Assert that a message was sent with a subject.
+   * Throws if no message was found.
+   */
+  assertSentWithSubject(subject) {
+    if (!this.hasSentWithSubject(subject)) {
+      throw new Error(`No email was sent with subject containing "${subject}"`);
+    }
+  }
+  /**
+   * Assert that exactly n messages were sent.
+   * Throws if count doesn't match.
+   */
+  assertSentCount(count) {
+    if (this.messages.length !== count) {
+      throw new Error(`Expected ${count} emails to be sent, but got ${this.messages.length}`);
+    }
+  }
+};
+
+// src/mail/MailManager.ts
+var MailManager = class {
+  defaultTransportName;
+  defaultFrom;
+  transportFactories = /* @__PURE__ */ new Map();
+  resolvedTransports = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.defaultTransportName = config.default ?? "smtp";
+    this.defaultFrom = config.from;
+    this.registerBuiltinDrivers();
+    if (config.transports) {
+      for (const [name, transportConfig] of Object.entries(config.transports)) {
+        this.registerTransportFromConfig(name, transportConfig);
+      }
+    }
+  }
+  /**
+   * Register built-in transport drivers.
+   */
+  registerBuiltinDrivers() {
+    this.registerDriverFactory("smtp", (options) => {
+      return new SmtpTransport(options);
+    });
+    this.registerDriverFactory("resend", (options) => {
+      return new ResendTransport(options);
+    });
+    this.registerDriverFactory("memory", (options) => {
+      return new MemoryTransport(options);
+    });
+  }
+  driverFactories = /* @__PURE__ */ new Map();
+  /**
+   * Register a driver factory.
+   */
+  registerDriverFactory(driver, factory) {
+    this.driverFactories.set(driver, factory);
+  }
+  /**
+   * Register a transport from configuration.
+   */
+  registerTransportFromConfig(name, config) {
+    const { driver, ...options } = config;
+    const factory = this.driverFactories.get(driver);
+    if (!factory) {
+      throw new Error(`Unknown mail driver: ${driver}`);
+    }
+    this.transportFactories.set(name, () => factory(options));
+  }
+  /**
+   * Get a mail transport by name.
+   * Returns the default transport if no name is specified.
+   */
+  transport(name) {
+    const transportName = name ?? this.defaultTransportName;
+    const cached = this.resolvedTransports.get(transportName);
+    if (cached) {
+      return cached;
+    }
+    const factory = this.transportFactories.get(transportName);
+    if (!factory) {
+      throw new Error(`Mail transport not found: ${transportName}`);
+    }
+    const transport = factory();
+    this.resolvedTransports.set(transportName, transport);
+    return transport;
+  }
+  /**
+   * Register a custom transport.
+   */
+  registerTransport(name, factory) {
+    this.transportFactories.set(name, factory);
+    this.resolvedTransports.delete(name);
+  }
+  /**
+   * Check if a transport is registered.
+   */
+  hasTransport(name) {
+    return this.transportFactories.has(name);
+  }
+  /**
+   * Get the default transport name.
+   */
+  getDefaultTransportName() {
+    return this.defaultTransportName;
+  }
+  /**
+   * Get the default from address.
+   */
+  getDefaultFrom() {
+    return this.defaultFrom;
+  }
+  /**
+   * Get all registered transport names.
+   */
+  getTransportNames() {
+    return Array.from(this.transportFactories.keys());
+  }
+};
+function createMailManager(config) {
+  return new MailManager(config);
+}
+
+// src/queue/Job.ts
+import { randomBytes } from "crypto";
+
+// src/container/Container.ts
+var globalContainer = null;
+function getContainer() {
+  if (!globalContainer) {
+    throw new Error("Container not initialized. Call setContainer() first.");
+  }
+  return globalContainer;
+}
+
+// src/queue/Job.ts
+var globalDriver = null;
+function getQueueDriver() {
+  return globalDriver;
+}
+function generateJobId() {
+  return randomBytes(16).toString("hex");
+}
+var Job = class {
+  /**
+   * The queue this job should be dispatched to.
+   * @default 'default'
+   */
+  static queue = "default";
+  /**
+   * Maximum number of times the job should be attempted.
+   * @default 3
+   */
+  static maxAttempts = 3;
+  /**
+   * Backoff strategy for retries.
+   * - 'exponential': 2^attempt * 1000ms (1s, 2s, 4s, 8s, ...)
+   * - 'linear': attempt * 1000ms (1s, 2s, 3s, 4s, ...)
+   * - number: fixed delay in milliseconds
+   * @default 'exponential'
+   */
+  static backoff = "exponential";
+  make(key) {
+    return getContainer().make(key);
+  }
+  /**
+   * Dispatch the job to the queue.
+   *
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options
+   */
+  static async dispatch(payload, options = {}) {
+    const driver = globalDriver;
+    if (!driver) {
+      throw new Error("Queue driver not configured. Call setQueueDriver() first.");
+    }
+    const jobId = generateJobId();
+    const now = /* @__PURE__ */ new Date();
+    const delay = options.delay ?? 0;
+    const job = {
+      id: jobId,
+      name: this.name,
+      payload,
+      queue: options.queue ?? this.queue,
+      attempts: 0,
+      maxAttempts: options.maxAttempts ?? this.maxAttempts,
+      availableAt: new Date(now.getTime() + delay),
+      createdAt: now,
+      reservedAt: null
+    };
+    await driver.push(job);
+    return jobId;
+  }
+  /**
+   * Dispatch the job after a delay.
+   *
+   * @param delayMs - Delay in milliseconds
+   * @param payload - Job payload data
+   * @param options - Optional dispatch options (delay is overridden)
+   */
+  static async dispatchAfter(delayMs, payload, options = {}) {
+    return this.dispatch(payload, { ...options, delay: delayMs });
+  }
+  /**
+   * Calculate the retry delay based on backoff strategy.
+   */
+  static calculateRetryDelay(attempts) {
+    if (typeof this.backoff === "number") {
+      return this.backoff;
+    }
+    if (this.backoff === "linear") {
+      return attempts * 1e3;
+    }
+    return Math.pow(2, attempts) * 1e3;
+  }
+};
+var jobRegistry = /* @__PURE__ */ new Map();
+function registerJob(jobClass) {
+  jobRegistry.set(jobClass.name, jobClass);
+}
+
+// src/mail/Mail.ts
+function parseAddress(input) {
+  if (typeof input === "string") {
+    const match = input.match(/^(.+)\s*<(.+)>$/);
+    if (match) {
+      return { name: match[1].trim(), email: match[2].trim() };
+    }
+    return { email: input };
+  }
+  return input;
+}
+var Mail = class {
+  constructor(manager) {
+    this.manager = manager;
+    const defaultFrom = manager.getDefaultFrom();
+    if (defaultFrom) {
+      this.message.from = defaultFrom;
+    }
+  }
+  message = {
+    to: [],
+    cc: [],
+    bcc: [],
+    attachments: []
+  };
+  transportName;
+  /**
+   * Set the sender address.
+   */
+  from(address) {
+    this.message.from = parseAddress(address);
+    return this;
+  }
+  /**
+   * Add a recipient.
+   */
+  to(address) {
+    this.message.to.push(parseAddress(address));
+    return this;
+  }
+  /**
+   * Add multiple recipients.
+   */
+  toMany(addresses) {
+    for (const addr of addresses) {
+      this.to(addr);
+    }
+    return this;
+  }
+  /**
+   * Add a CC recipient.
+   */
+  cc(address) {
+    this.message.cc.push(parseAddress(address));
+    return this;
+  }
+  /**
+   * Add a BCC recipient.
+   */
+  bcc(address) {
+    this.message.bcc.push(parseAddress(address));
+    return this;
+  }
+  /**
+   * Set the reply-to address.
+   */
+  replyTo(address) {
+    this.message.replyTo = parseAddress(address);
+    return this;
+  }
+  /**
+   * Set the subject.
+   */
+  subject(subject) {
+    this.message.subject = subject;
+    return this;
+  }
+  /**
+   * Set the plain text body.
+   */
+  text(content) {
+    this.message.text = content;
+    return this;
+  }
+  /**
+   * Set the HTML body.
+   */
+  html(content) {
+    this.message.html = content;
+    return this;
+  }
+  /**
+   * Render a React component as HTML body.
+   * Requires @react-email/render to be installed.
+   *
+   * @param component - React component function
+   * @param props - Props to pass to the component
+   */
+  async template(component, props) {
+    try {
+      const reactEmailModule = "@react-email/render";
+      const reactEmail = await import(
+        /* @vite-ignore */
+        reactEmailModule
+      );
+      const html = await reactEmail.render(component(props));
+      this.message.html = html;
+    } catch (error) {
+      throw new Error(
+        "Failed to render email template. Make sure @react-email/render is installed."
+      );
+    }
+    return this;
+  }
+  /**
+   * Add an attachment.
+   */
+  attach(attachment) {
+    this.message.attachments.push(attachment);
+    return this;
+  }
+  /**
+   * Add a custom header.
+   */
+  header(key, value) {
+    if (!this.message.headers) {
+      this.message.headers = {};
+    }
+    this.message.headers[key] = value;
+    return this;
+  }
+  /**
+   * Specify which transport to use.
+   */
+  via(transport) {
+    this.transportName = transport;
+    return this;
+  }
+  /**
+   * Build the final message.
+   */
+  buildMessage() {
+    if (!this.message.to || this.message.to.length === 0) {
+      throw new Error("Email must have at least one recipient");
+    }
+    if (!this.message.subject) {
+      throw new Error("Email must have a subject");
+    }
+    if (!this.message.text && !this.message.html) {
+      throw new Error("Email must have a text or html body");
+    }
+    return this.message;
+  }
+  /**
+   * Send the email immediately.
+   */
+  async send() {
+    const message = this.buildMessage();
+    const transport = this.manager.transport(this.transportName);
+    return transport.send(message);
+  }
+  /**
+   * Queue the email for async sending.
+   */
+  async queue(queueName = "default") {
+    const driver = getQueueDriver();
+    if (!driver) {
+      throw new Error("Queue driver not configured. Use send() instead or configure a queue driver.");
+    }
+    const message = this.buildMessage();
+    registerJob(SendMailJob);
+    return SendMailJob.dispatch(
+      {
+        message,
+        transport: this.transportName ?? this.manager.getDefaultTransportName()
+      },
+      { queue: queueName }
+    );
+  }
+};
+var globalMailManager = null;
+function setMailManager(manager) {
+  globalMailManager = manager;
+}
+function getMailManager() {
+  return globalMailManager;
+}
+var SendMailJob = class extends Job {
+  static queue = "default";
+  static maxAttempts = 3;
+  static backoff = "exponential";
+  async handle(payload) {
+    const manager = globalMailManager;
+    if (!manager) {
+      throw new Error("Mail manager not configured for queue jobs. Call setMailManager() first.");
+    }
+    const transport = manager.transport(payload.transport);
+    const result = await transport.send(payload.message);
+    if (!result.success) {
+      throw new Error(result.error ?? "Failed to send email");
+    }
+  }
+};
+function mail(manager) {
+  return new Mail(manager);
+}
+export {
+  Mail,
+  MailManager,
+  MemoryTransport,
+  ResendTransport,
+  SmtpTransport,
+  createMailManager,
+  getMailManager,
+  mail,
+  setMailManager
+};