@igniter-js/mail 0.1.0

package/dist/index.js

@@ -0,0 +1,880 @@
+'use strict';
+
+var core = require('@igniter-js/core');
+var resend = require('resend');
+var nodemailer = require('nodemailer');
+var React = require('react');
+var components = require('@react-email/components');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var nodemailer__default = /*#__PURE__*/_interopDefault(nodemailer);
+var React__default = /*#__PURE__*/_interopDefault(React);
+
+// src/errors/igniter-mail.error.ts
+var IgniterMailError = class _IgniterMailError extends core.IgniterError {
+  constructor(payload) {
+    super({
+      code: payload.code,
+      message: payload.message,
+      statusCode: payload.statusCode,
+      causer: "@igniter-js/mail",
+      details: payload.details,
+      metadata: payload.metadata,
+      logger: payload.logger
+    });
+    this.name = "IgniterMailError";
+  }
+  /**
+   * Type guard utility.
+   */
+  static is(error) {
+    return error instanceof _IgniterMailError;
+  }
+};
+
+// src/adapters/postmark.adapter.ts
+var PostmarkMailAdapterBuilder = class _PostmarkMailAdapterBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _PostmarkMailAdapterBuilder();
+  }
+  /** Sets the Postmark Server Token. */
+  withSecret(secret) {
+    this.secret = secret;
+    return this;
+  }
+  /** Sets the default FROM address used when sending emails via Postmark. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Builds the adapter instance. */
+  build() {
+    if (!this.secret) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Postmark adapter secret is required"
+      });
+    }
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Postmark adapter from is required"
+      });
+    }
+    const token = this.secret;
+    const from = this.from;
+    return {
+      /** Sends an email using Postmark (HTTP API). */
+      send: async ({ to, subject, html, text }) => {
+        const response = await fetch("https://api.postmarkapp.com/email", {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "X-Postmark-Server-Token": token
+          },
+          body: JSON.stringify({
+            From: from,
+            To: to,
+            Subject: subject,
+            HtmlBody: html,
+            TextBody: text
+          })
+        });
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new IgniterMailError({
+            code: "MAIL_PROVIDER_SEND_FAILED",
+            message: "Postmark send failed",
+            metadata: {
+              status: response.status,
+              body
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var postmarkAdapter = (options) => PostmarkMailAdapterBuilder.create().withSecret(options.secret).withFrom(options.from).build();
+var ResendMailAdapterBuilder = class _ResendMailAdapterBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _ResendMailAdapterBuilder();
+  }
+  /** Sets the Resend API key. */
+  withSecret(secret) {
+    this.secret = secret;
+    return this;
+  }
+  /** Sets the default FROM address used when sending emails via Resend. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Builds the adapter instance. */
+  build() {
+    if (!this.secret) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Resend adapter secret is required"
+      });
+    }
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Resend adapter from is required"
+      });
+    }
+    const resend$1 = new resend.Resend(this.secret);
+    const from = this.from;
+    return {
+      /**
+       * Sends an email using Resend.
+       *
+       * Note: Resend accepts `scheduledAt` as an ISO string.
+       */
+      send: async ({ to, subject, html, text, scheduledAt }) => {
+        await resend$1.emails.create({
+          to,
+          from,
+          subject,
+          html,
+          text,
+          scheduledAt: scheduledAt?.toISOString()
+        });
+      }
+    };
+  }
+};
+var resendAdapter = (options) => ResendMailAdapterBuilder.create().withSecret(options.secret).withFrom(options.from).build();
+
+// src/adapters/sendgrid.adapter.ts
+var SendGridMailAdapterBuilder = class _SendGridMailAdapterBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _SendGridMailAdapterBuilder();
+  }
+  /** Sets the SendGrid API key. */
+  withSecret(secret) {
+    this.secret = secret;
+    return this;
+  }
+  /** Sets the default FROM address used when sending emails via SendGrid. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Builds the adapter instance. */
+  build() {
+    if (!this.secret) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "SendGrid adapter secret is required"
+      });
+    }
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "SendGrid adapter from is required"
+      });
+    }
+    const apiKey = this.secret;
+    const from = this.from;
+    return {
+      /** Sends an email using SendGrid (HTTP API). */
+      send: async ({ to, subject, html, text }) => {
+        const response = await fetch("https://api.sendgrid.com/v3/mail/send", {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            personalizations: [{
+              to: [{ email: to }]
+            }],
+            from: { email: from },
+            subject,
+            content: [
+              { type: "text/plain", value: text },
+              { type: "text/html", value: html }
+            ]
+          })
+        });
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new IgniterMailError({
+            code: "MAIL_PROVIDER_SEND_FAILED",
+            message: "SendGrid send failed",
+            metadata: {
+              status: response.status,
+              body
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var sendgridAdapter = (options) => SendGridMailAdapterBuilder.create().withSecret(options.secret).withFrom(options.from).build();
+var SmtpMailAdapterBuilder = class _SmtpMailAdapterBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _SmtpMailAdapterBuilder();
+  }
+  /** Sets the SMTP connection URL (e.g. `smtps://user:pass@host:port`). */
+  withSecret(secret) {
+    this.secret = secret;
+    return this;
+  }
+  /** Sets the default FROM address used when sending emails via SMTP. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Builds the adapter instance. */
+  build() {
+    if (!this.secret) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "SMTP adapter secret is required"
+      });
+    }
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "SMTP adapter from is required"
+      });
+    }
+    const smtpUrl = this.secret;
+    const from = this.from;
+    const createTransporter = () => {
+      return nodemailer__default.default.createTransport(smtpUrl, {
+        tls: {
+          rejectUnauthorized: false
+        },
+        connectionTimeout: 1e4,
+        greetingTimeout: 5e3,
+        socketTimeout: 1e4
+      });
+    };
+    return {
+      /** Sends an email using Nodemailer over SMTP. */
+      send: async ({ to, subject, html, text }) => {
+        const transport = createTransporter();
+        const mailOptions = {
+          from,
+          to,
+          subject,
+          html,
+          text
+        };
+        try {
+          await transport.sendMail(mailOptions);
+          transport.close();
+        } catch (error) {
+          transport.close();
+          throw error;
+        }
+      }
+    };
+  }
+};
+var smtpAdapter = (options) => SmtpMailAdapterBuilder.create().withSecret(options.secret).withFrom(options.from).build();
+
+// src/adapters/test.adapter.ts
+function createTestMailAdapter(options = {}) {
+  const sent = [];
+  const logger = options.logger ?? console;
+  const silent = options.silent ?? false;
+  return {
+    sent,
+    reset: () => {
+      sent.length = 0;
+    },
+    last: () => sent.at(-1),
+    send: async (params) => {
+      sent.push({ ...params, at: /* @__PURE__ */ new Date() });
+      if (!silent) {
+        logger.info(
+          `[TestMailAdapter] to=${params.to} subject=${params.subject} html=${params.html.length}B text=${params.text.length}B`
+        );
+      }
+    }
+  };
+}
+
+// src/adapters/webhook.adapter.ts
+var WebhookMailAdapterBuilder = class _WebhookMailAdapterBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _WebhookMailAdapterBuilder();
+  }
+  /**
+   * Sets the webhook URL.
+   *
+   * Note: when using `IgniterMailBuilder.withAdapter('webhook', secret)`, the `secret`
+   * is treated as the webhook URL.
+   */
+  withUrl(url) {
+    this.url = url;
+    return this;
+  }
+  /** Sets the default FROM address. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Builds the adapter instance. */
+  build() {
+    if (!this.url) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Webhook adapter url is required"
+      });
+    }
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_ADAPTER_CONFIGURATION_INVALID",
+        message: "Webhook adapter from is required"
+      });
+    }
+    const url = this.url;
+    const from = this.from;
+    return {
+      /** Sends an email by POST-ing to the configured webhook URL. */
+      send: async ({ to, subject, html, text, scheduledAt }) => {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            to,
+            from,
+            subject,
+            html,
+            text,
+            scheduledAt: scheduledAt?.toISOString()
+          })
+        });
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          throw new IgniterMailError({
+            code: "MAIL_PROVIDER_SEND_FAILED",
+            message: "Webhook send failed",
+            metadata: {
+              status: response.status,
+              body
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var webhookAdapter = (options) => WebhookMailAdapterBuilder.create().withUrl(options.secret).withFrom(options.from).build();
+
+// src/builders/igniter-mail.builder.ts
+var IgniterMailBuilder = class _IgniterMailBuilder {
+  constructor(factory) {
+    this.templates = {};
+    this.factory = factory;
+  }
+  /**
+   * Creates a new builder.
+   */
+  static create(factory) {
+    return new _IgniterMailBuilder(factory);
+  }
+  /** Sets the default FROM address. */
+  withFrom(from) {
+    this.from = from;
+    return this;
+  }
+  /** Attaches a logger instance. */
+  withLogger(logger) {
+    this.logger = logger;
+    return this;
+  }
+  /**
+   * Enables queue delivery.
+   *
+   * If configured, `IgniterMail.schedule()` will enqueue jobs instead of using `setTimeout`.
+   */
+  withQueue(adapter, options) {
+    this.queue = { adapter, options };
+    return this;
+  }
+  withAdapter(adapterOrProvider, secret) {
+    if (typeof adapterOrProvider === "string") {
+      if (!secret) {
+        throw new IgniterMailError({
+          code: "MAIL_PROVIDER_ADAPTER_SECRET_REQUIRED",
+          message: "MAIL_PROVIDER_ADAPTER_SECRET_REQUIRED",
+          logger: this.logger
+        });
+      }
+      this.adapter = {
+        kind: "provider",
+        provider: adapterOrProvider,
+        secret
+      };
+      return this;
+    }
+    this.adapter = {
+      kind: "adapter",
+      adapter: adapterOrProvider
+    };
+    return this;
+  }
+  /**
+   * Registers a template.
+   */
+  addTemplate(key, template) {
+    this.templates[key] = template;
+    return this;
+  }
+  /** Hook invoked before sending. */
+  withOnSendStarted(onSendStarted) {
+    this.onSendStarted = onSendStarted;
+    return this;
+  }
+  /** Hook invoked on error. */
+  withOnSendError(onSendError) {
+    this.onSendError = onSendError;
+    return this;
+  }
+  /** Hook invoked on success. */
+  withOnSendSuccess(onSendSuccess) {
+    this.onSendSuccess = onSendSuccess;
+    return this;
+  }
+  /**
+   * Builds the {@link IgniterMail} instance.
+   */
+  build() {
+    if (!this.from) {
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_FROM_REQUIRED",
+        message: "MAIL_PROVIDER_FROM_REQUIRED",
+        logger: this.logger
+      });
+    }
+    if (!this.adapter) {
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_ADAPTER_REQUIRED",
+        message: "MAIL_PROVIDER_ADAPTER_REQUIRED",
+        logger: this.logger
+      });
+    }
+    const resolvedAdapter = this.adapter.kind === "adapter" ? this.adapter.adapter : (() => {
+      switch (this.adapter.provider) {
+        case "resend":
+          return ResendMailAdapterBuilder.create().withSecret(this.adapter.secret).withFrom(this.from).build();
+        case "smtp":
+          return SmtpMailAdapterBuilder.create().withSecret(this.adapter.secret).withFrom(this.from).build();
+        case "postmark":
+          return PostmarkMailAdapterBuilder.create().withSecret(this.adapter.secret).withFrom(this.from).build();
+        case "sendgrid":
+          return SendGridMailAdapterBuilder.create().withSecret(this.adapter.secret).withFrom(this.from).build();
+        case "webhook":
+          return WebhookMailAdapterBuilder.create().withUrl(this.adapter.secret).withFrom(this.from).build();
+        default:
+          throw new IgniterMailError({
+            code: "MAIL_PROVIDER_ADAPTER_NOT_FOUND",
+            message: `MAIL_PROVIDER_ADAPTER_NOT_FOUND: ${this.adapter.provider}`,
+            logger: this.logger,
+            metadata: {
+              provider: this.adapter.provider
+            }
+          });
+      }
+    })();
+    return this.factory({
+      from: this.from,
+      adapter: resolvedAdapter,
+      templates: this.templates,
+      onSendStarted: this.onSendStarted,
+      onSendError: this.onSendError,
+      onSendSuccess: this.onSendSuccess,
+      logger: this.logger,
+      queue: this.queue ? {
+        adapter: this.queue.adapter,
+        id: `${this.queue.options?.namespace ?? "mail"}.${this.queue.options?.task ?? "send"}`,
+        options: this.queue.options
+      } : void 0
+    });
+  }
+};
+
+// src/builders/mail-template.builder.ts
+var MailTemplateBuilder = class _MailTemplateBuilder {
+  /** Creates a new builder instance. */
+  static create() {
+    return new _MailTemplateBuilder();
+  }
+  /** Sets the default subject for the template. */
+  withSubject(subject) {
+    this.subject = subject;
+    return this;
+  }
+  /** Attaches the schema used to validate and infer payload types. */
+  withSchema(schema) {
+    this.schema = schema;
+    return this;
+  }
+  /** Sets the React Email render function for the template. */
+  withRender(render2) {
+    this.render = render2;
+    return this;
+  }
+  /** Builds the template definition. */
+  build() {
+    if (!this.subject) {
+      throw new IgniterMailError({
+        code: "MAIL_TEMPLATE_CONFIGURATION_INVALID",
+        message: "Mail template subject is required"
+      });
+    }
+    if (!this.schema) {
+      throw new IgniterMailError({
+        code: "MAIL_TEMPLATE_CONFIGURATION_INVALID",
+        message: "Mail template schema is required"
+      });
+    }
+    if (!this.render) {
+      throw new IgniterMailError({
+        code: "MAIL_TEMPLATE_CONFIGURATION_INVALID",
+        message: "Mail template render is required"
+      });
+    }
+    return {
+      subject: this.subject,
+      schema: this.schema,
+      render: this.render
+    };
+  }
+};
+
+// src/utils/validate-standard-schema-input.ts
+async function validateStandardSchemaInput(schema, input) {
+  const standard = schema?.["~standard"];
+  if (!standard?.validate) {
+    return input;
+  }
+  const result = await standard.validate(input);
+  if (result?.issues?.length) {
+    throw new IgniterMailError({
+      code: "MAIL_PROVIDER_TEMPLATE_DATA_INVALID",
+      message: "Invalid mail template payload",
+      statusCode: 400,
+      details: result.issues
+    });
+  }
+  return result?.value ?? input;
+}
+
+// src/core/igniter-mail.tsx
+var _IgniterMail = class _IgniterMail {
+  constructor(options) {
+    this.queueJobRegistered = false;
+    /**
+     * Type inference helper.
+     * Access via `typeof mail.$Infer` (type-level only).
+     */
+    this.$Infer = void 0;
+    const { adapter, templates, logger, queue, ...rest } = options;
+    if (!adapter) {
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_ADAPTER_REQUIRED",
+        message: "MAIL_PROVIDER_ADAPTER_REQUIRED",
+        logger
+      });
+    }
+    if (!templates) {
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_TEMPLATES_REQUIRED",
+        message: "MAIL_PROVIDER_TEMPLATES_REQUIRED",
+        logger
+      });
+    }
+    this.adapter = adapter;
+    this.templates = templates;
+    this.logger = logger;
+    this.queue = queue;
+    this.options = rest;
+  }
+  async ensureQueueJobRegistered() {
+    const queue = this.queue;
+    if (!queue) return;
+    if (this.queueJobRegistered) return;
+    if (this.queueJobRegistering) {
+      await this.queueJobRegistering;
+      return;
+    }
+    this.queueJobRegistering = (async () => {
+      const queueOptions = queue.options;
+      const name = queueOptions?.name ?? "send";
+      const passthroughSchema = {
+        "~standard": {
+          vendor: "@igniter-js/mail",
+          version: 1,
+          validate: async (value) => ({ value })
+        }
+      };
+      const definition = queue.adapter.register({
+        name,
+        input: passthroughSchema,
+        handler: async ({ input }) => {
+          await this.send(input);
+        },
+        queue: queueOptions?.queue,
+        attempts: queueOptions?.attempts,
+        priority: queueOptions?.priority,
+        removeOnComplete: queueOptions?.removeOnComplete,
+        removeOnFail: queueOptions?.removeOnFail,
+        metadata: queueOptions?.metadata,
+        limiter: queueOptions?.limiter
+      });
+      await queue.adapter.bulkRegister({
+        [queue.id]: definition
+      });
+      this.queueJobRegistered = true;
+    })();
+    try {
+      await this.queueJobRegistering;
+    } finally {
+      this.queueJobRegistering = void 0;
+    }
+  }
+  async validateTemplateData(template, data) {
+    try {
+      return await validateStandardSchemaInput(
+        template.schema,
+        data
+      );
+    } catch (error) {
+      const normalizedError = IgniterMailError.is(error) ? error : new IgniterMailError({
+        code: "MAIL_PROVIDER_TEMPLATE_DATA_INVALID",
+        message: "MAIL_PROVIDER_TEMPLATE_DATA_INVALID",
+        cause: error,
+        logger: this.logger,
+        metadata: { subject: String(template.subject) }
+      });
+      throw normalizedError;
+    }
+  }
+  /**
+   * Sends an email immediately.
+   */
+  async send(params) {
+    try {
+      this.logger?.debug("IgniterMail.send started", {
+        to: params.to,
+        template: String(params.template)
+      });
+      await this.onSendStarted(params);
+      const template = this.templates[params.template];
+      if (!template) {
+        throw new IgniterMailError({
+          code: "MAIL_PROVIDER_TEMPLATE_NOT_FOUND",
+          message: "MAIL_PROVIDER_TEMPLATE_NOT_FOUND",
+          logger: this.logger,
+          metadata: {
+            template: String(params.template)
+          }
+        });
+      }
+      const validatedData = await this.validateTemplateData(
+        template,
+        params.data
+      );
+      const MailTemplate = template.render;
+      const html = await components.render(/* @__PURE__ */ React__default.default.createElement(MailTemplate, { ...validatedData }));
+      const text = await components.render(/* @__PURE__ */ React__default.default.createElement(MailTemplate, { ...validatedData }), {
+        plainText: true
+      });
+      await this.adapter.send({
+        to: params.to,
+        subject: params.subject || template.subject,
+        html,
+        text
+      });
+      await this.onSendSuccess(params);
+      this.logger?.info("IgniterMail.send success", {
+        to: params.to,
+        template: String(params.template)
+      });
+    } catch (error) {
+      const normalizedError = IgniterMailError.is(error) ? error : new IgniterMailError({
+        code: "MAIL_PROVIDER_SEND_FAILED",
+        message: "MAIL_PROVIDER_SEND_FAILED",
+        cause: error,
+        logger: this.logger,
+        metadata: {
+          to: params.to,
+          template: String(params.template)
+        }
+      });
+      this.logger?.error("IgniterMail.send failed", normalizedError);
+      await this.onSendError(params, normalizedError);
+      throw normalizedError;
+    }
+  }
+  /**
+   * Schedules an email for a future date.
+   *
+   * If a queue is configured, this method enqueues a job.
+   * Otherwise, it uses a best-effort `setTimeout`.
+   */
+  async schedule(params, date) {
+    if (date.getTime() <= Date.now()) {
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_SCHEDULE_DATE_INVALID",
+        message: "MAIL_PROVIDER_SCHEDULE_DATE_INVALID",
+        logger: this.logger
+      });
+    }
+    if (this.queue) {
+      try {
+        await this.ensureQueueJobRegistered();
+        const delay = Math.max(0, date.getTime() - Date.now());
+        this.logger?.info("IgniterMail.schedule enqueued", {
+          id: this.queue.id,
+          to: params.to,
+          template: String(params.template),
+          delay
+        });
+        await this.queue.adapter.invoke({
+          id: this.queue.id,
+          input: params,
+          delay
+        });
+        return;
+      } catch (error) {
+        const normalizedError = IgniterMailError.is(error) ? error : new IgniterMailError({
+          code: "MAIL_PROVIDER_SCHEDULE_FAILED",
+          message: "MAIL_PROVIDER_SCHEDULE_FAILED",
+          cause: error,
+          logger: this.logger,
+          metadata: {
+            to: params.to,
+            template: String(params.template),
+            date: date.toISOString()
+          }
+        });
+        this.logger?.error("IgniterMail.schedule failed", normalizedError);
+        throw normalizedError;
+      }
+    }
+    const timeout = date.getTime() - Date.now();
+    setTimeout(() => {
+      this.send(params).catch((error) => {
+        console.error("Failed to send scheduled email:", error);
+      });
+    }, timeout);
+  }
+  async onSendStarted(params) {
+    await this.options.onSendStarted?.(params);
+  }
+  async onSendError(params, error) {
+    await this.options.onSendError?.(params, error);
+  }
+  async onSendSuccess(params) {
+    await this.options.onSendSuccess?.(params);
+  }
+};
+/** Helper to declare adapter factories. */
+_IgniterMail.adapter = (adapter) => adapter;
+/** Helper to declare templates with inferred payload types. */
+_IgniterMail.template = (template) => template;
+/**
+ * Creates a new builder instance.
+ */
+_IgniterMail.create = () => IgniterMailBuilder.create((options) => new _IgniterMail(options));
+/**
+ * Initializes (singleton) instance.
+ *
+ * Prefer using {@link IgniterMail.create} for new code.
+ */
+_IgniterMail.initialize = (options) => {
+  if (_IgniterMail.instance) {
+    return _IgniterMail.instance;
+  }
+  const adapter = options.adapter;
+  if (typeof adapter === "function") {
+    const legacyOptions = options;
+    _IgniterMail.instance = new _IgniterMail({
+      from: legacyOptions.from,
+      templates: legacyOptions.templates,
+      adapter: legacyOptions.adapter(legacyOptions),
+      onSendStarted: legacyOptions.onSendStarted,
+      onSendError: legacyOptions.onSendError,
+      onSendSuccess: legacyOptions.onSendSuccess
+    });
+    return _IgniterMail.instance;
+  }
+  _IgniterMail.instance = new _IgniterMail(
+    options
+  );
+  return _IgniterMail.instance;
+};
+var IgniterMail = _IgniterMail;
+
+// src/types/provider.ts
+function createPassthroughSchema() {
+  return {
+    "~standard": {
+      vendor: "@igniter-js/mail",
+      version: 1,
+      validate: async (value) => ({ value })
+    }
+  };
+}
+
+// src/utils/get-adapter.ts
+var getAdapter = (adapter) => {
+  switch (adapter) {
+    case "resend":
+      return resendAdapter;
+    case "smtp":
+      return smtpAdapter;
+    case "postmark":
+      return postmarkAdapter;
+    case "sendgrid":
+      return sendgridAdapter;
+    case "webhook":
+      return webhookAdapter;
+    default:
+      throw new IgniterMailError({
+        code: "MAIL_PROVIDER_ADAPTER_NOT_FOUND",
+        message: `MAIL_PROVIDER_ADAPTER_NOT_FOUND: ${adapter}`,
+        metadata: { adapter }
+      });
+  }
+};
+
+exports.IgniterMail = IgniterMail;
+exports.IgniterMailBuilder = IgniterMailBuilder;
+exports.IgniterMailError = IgniterMailError;
+exports.MailTemplateBuilder = MailTemplateBuilder;
+exports.PostmarkMailAdapterBuilder = PostmarkMailAdapterBuilder;
+exports.ResendMailAdapterBuilder = ResendMailAdapterBuilder;
+exports.SendGridMailAdapterBuilder = SendGridMailAdapterBuilder;
+exports.SmtpMailAdapterBuilder = SmtpMailAdapterBuilder;
+exports.WebhookMailAdapterBuilder = WebhookMailAdapterBuilder;
+exports.createPassthroughSchema = createPassthroughSchema;
+exports.createTestMailAdapter = createTestMailAdapter;
+exports.getAdapter = getAdapter;
+exports.postmarkAdapter = postmarkAdapter;
+exports.resendAdapter = resendAdapter;
+exports.sendgridAdapter = sendgridAdapter;
+exports.smtpAdapter = smtpAdapter;
+exports.validateStandardSchemaInput = validateStandardSchemaInput;
+exports.webhookAdapter = webhookAdapter;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map