@objectstack/plugin-email 4.0.1

package/dist/index.mjs

@@ -0,0 +1,835 @@
+// src/email-plugin.ts
+import { SysEmail, SysEmailTemplate } from "@objectstack/platform-objects/audit";
+
+// src/template-engine.ts
+var PLACEHOLDER = /(\{\{\{?)\s*([\w.]+)\s*(\}?\}\})/g;
+function lookup(data, path) {
+  if (!path) return void 0;
+  const parts = path.split(".");
+  let cur = data;
+  for (const p of parts) {
+    if (cur == null) return void 0;
+    cur = cur[p];
+  }
+  return cur;
+}
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderTemplate(template, data) {
+  if (!template) return "";
+  return template.replace(PLACEHOLDER, (_match, open, path, close) => {
+    const isUnescaped = open === "{{{" && close === "}}}";
+    const raw = lookup(data, path);
+    if (raw == null) return "";
+    const str = typeof raw === "string" ? raw : String(raw);
+    return isUnescaped ? str : escapeHtml(str);
+  });
+}
+function requireVars(data, required) {
+  const missing = required.filter((name) => lookup(data, name) == null);
+  if (missing.length > 0) {
+    throw new Error(`MISSING_VARIABLES: ${missing.join(", ")}`);
+  }
+}
+function htmlToText(html) {
+  if (!html) return "";
+  return html.replace(/<br\s*\/?>/gi, "\n").replace(/<\/(p|div|h[1-6]|li|tr)>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/[ \t]+/g, " ").replace(/\n[ \t]+/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+// src/email-service.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+function formatAddress(addr) {
+  const obj = typeof addr === "string" ? { address: addr } : addr;
+  const address = String(obj.address ?? "").trim();
+  if (!EMAIL_REGEX.test(address)) {
+    throw new Error(`Invalid email address: ${address || "(empty)"}`);
+  }
+  const name = obj.name?.trim();
+  if (!name) return address;
+  const needsQuote = /[",()<>@:;.\\\[\]]/.test(name);
+  const quoted = needsQuote ? `"${name.replace(/"/g, '\\"')}"` : name;
+  return `${quoted} <${address}>`;
+}
+function listToArray(v) {
+  if (v === void 0) return void 0;
+  const arr = Array.isArray(v) ? v : [v];
+  return arr.map(formatAddress);
+}
+function normalizeMessage(input, defaultFrom) {
+  if (!input || typeof input !== "object") {
+    throw new Error("VALIDATION_FAILED: input must be an object");
+  }
+  const subject = String(input.subject ?? "").trim();
+  if (!subject) throw new Error("VALIDATION_FAILED: subject is required");
+  if (!input.text && !input.html) {
+    throw new Error("VALIDATION_FAILED: at least one of text or html is required");
+  }
+  const toArr = listToArray(input.to);
+  if (!toArr || toArr.length === 0) {
+    throw new Error("VALIDATION_FAILED: at least one recipient (to) is required");
+  }
+  const fromCandidate = input.from ?? defaultFrom;
+  if (!fromCandidate) {
+    throw new Error("VALIDATION_FAILED: from address required (set options.defaultFrom or pass input.from)");
+  }
+  const from = formatAddress(fromCandidate);
+  const msg = {
+    to: toArr,
+    from,
+    subject,
+    ...input.text !== void 0 ? { text: input.text } : {},
+    ...input.html !== void 0 ? { html: input.html } : {}
+  };
+  const cc = listToArray(input.cc);
+  if (cc && cc.length > 0) msg.cc = cc;
+  const bcc = listToArray(input.bcc);
+  if (bcc && bcc.length > 0) msg.bcc = bcc;
+  if (input.replyTo) msg.replyTo = formatAddress(input.replyTo);
+  if (input.attachments && input.attachments.length > 0) msg.attachments = input.attachments;
+  if (input.headers && Object.keys(input.headers).length > 0) msg.headers = input.headers;
+  return msg;
+}
+var LogTransport = class {
+  constructor(logger) {
+    this.logger = logger;
+    this.counter = 0;
+  }
+  async send(message) {
+    const messageId = `<dev-${Date.now()}-${++this.counter}@objectstack.local>`;
+    this.logger?.info("[LogTransport] would send email", {
+      messageId,
+      to: message.to,
+      from: message.from,
+      subject: message.subject,
+      hasText: !!message.text,
+      hasHtml: !!message.html,
+      attachments: message.attachments?.length ?? 0
+    });
+    return { messageId, response: "logged" };
+  }
+};
+function newId() {
+  try {
+    const g = globalThis.crypto;
+    if (g?.randomUUID) return g.randomUUID();
+  } catch {
+  }
+  const hex = (n) => Math.floor(Math.random() * 16 ** n).toString(16).padStart(n, "0");
+  return `${hex(8)}-${hex(4)}-4${hex(3)}-a${hex(3)}-${hex(12)}`;
+}
+var EmailService = class {
+  constructor(options) {
+    this.options = options;
+    if (!options.transport) throw new Error("EmailService: transport is required");
+  }
+  /** Wire (or replace) the template loader after construction. */
+  setTemplateLoader(loader) {
+    this.options.templateLoader = loader;
+  }
+  /** Wire (or replace) persistence after construction. */
+  setPersistence(persistence) {
+    this.options.persistence = persistence;
+  }
+  /**
+   * Hot-swap the underlying transport. Used by EmailServicePlugin when
+   * the `mail` settings namespace changes (e.g. SMTP host updated in
+   * the admin UI) so subsequent `send()` calls go through the new
+   * transport without restarting the process.
+   */
+  setTransport(transport) {
+    this.options.transport = transport;
+  }
+  /** Replace the default `from` address used when callers omit `input.from`. */
+  setDefaultFrom(from) {
+    this.options.defaultFrom = from;
+  }
+  async send(input) {
+    let normalized;
+    try {
+      normalized = normalizeMessage(input, this.options.defaultFrom);
+    } catch (err) {
+      throw err;
+    }
+    const id = newId();
+    const baseRow = {
+      id,
+      from_address: normalized.from,
+      to_addresses: normalized.to.join(", "),
+      ...normalized.cc?.length ? { cc_addresses: normalized.cc.join(", ") } : {},
+      ...normalized.bcc?.length ? { bcc_addresses: normalized.bcc.join(", ") } : {},
+      ...normalized.replyTo ? { reply_to: normalized.replyTo } : {},
+      subject: normalized.subject,
+      ...normalized.text !== void 0 ? { body_text: normalized.text } : {},
+      ...normalized.html !== void 0 ? { body_html: normalized.html } : {},
+      ...input.relatedObject ? { related_object: input.relatedObject } : {},
+      ...input.relatedId ? { related_id: input.relatedId } : {},
+      ...input.sentBy ? { sent_by: input.sentBy } : {},
+      status: "queued",
+      attempt_count: 0
+    };
+    let persistedId;
+    if (this.options.persistence) {
+      try {
+        const res = await this.options.persistence.insert(baseRow);
+        persistedId = typeof res === "string" ? res : res?.id ?? id;
+      } catch (err) {
+        this.options.logger?.warn("EmailService: sys_email persist failed (non-fatal)", { error: err?.message });
+      }
+    }
+    const rowId = persistedId ?? id;
+    const maxAttempts = (this.options.retries ?? 0) + 1;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const result = await this.options.transport.send(normalized);
+        const messageId = result.messageId;
+        const status = "sent";
+        await this.updateRow(rowId, {
+          status,
+          message_id: messageId,
+          sent_at: (/* @__PURE__ */ new Date()).toISOString(),
+          attempt_count: attempt
+        });
+        return { id: rowId, status, messageId };
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxAttempts) {
+          await new Promise((r) => setTimeout(r, Math.min(2e3, 100 * 2 ** (attempt - 1))));
+        }
+      }
+    }
+    const errMessage = String(lastError?.message ?? lastError ?? "send failed").slice(0, 1e3);
+    await this.updateRow(rowId, {
+      status: "failed",
+      error: errMessage,
+      attempt_count: maxAttempts
+    });
+    return { id: rowId, status: "failed", error: errMessage };
+  }
+  async updateRow(id, patch) {
+    if (!this.options.persistence?.update) return;
+    try {
+      await this.options.persistence.update(id, patch);
+    } catch (err) {
+      this.options.logger?.warn("EmailService: sys_email update failed (non-fatal)", { id, error: err?.message });
+    }
+  }
+  /**
+   * Render a named template from sys_email_template and deliver via
+   * send(). Looks up `(name, locale)` then falls back to `(name, 'en-US')`.
+   */
+  async sendTemplate(input) {
+    if (!input?.template) {
+      throw new Error("VALIDATION_FAILED: template name is required");
+    }
+    const loader = this.options.templateLoader;
+    if (!loader) {
+      throw new Error("TEMPLATE_NOT_FOUND: no templateLoader configured on EmailService");
+    }
+    const preferred = input.locale && String(input.locale).trim();
+    let row = await loader.load(input.template, preferred || void 0);
+    if (!row && preferred && preferred !== "en-US") {
+      row = await loader.load(input.template, "en-US");
+    }
+    if (!row) {
+      throw new Error(`TEMPLATE_NOT_FOUND: ${input.template} (locale=${preferred || "en-US"})`);
+    }
+    if (row.active === false) {
+      throw new Error(`TEMPLATE_INACTIVE: ${input.template}`);
+    }
+    const data = {
+      ...this.options.defaultTemplateContext || {},
+      ...input.data || {}
+    };
+    if (row.variables_json) {
+      try {
+        const decl = JSON.parse(String(row.variables_json));
+        const required = decl.filter((v) => v?.required).map((v) => v.name);
+        if (required.length) requireVars(data, required);
+      } catch (err) {
+        if (String(err?.message).startsWith("MISSING_VARIABLES")) throw err;
+        this.options.logger?.warn("EmailService: variables_json parse failed (ignored)", { template: input.template });
+      }
+    }
+    const subject = renderTemplate(row.subject, data);
+    const html = renderTemplate(row.body_html, data);
+    const text = row.body_text ? renderTemplate(row.body_text, data) : htmlToText(html);
+    const from = input.from ?? (row.from_address ? { address: row.from_address, ...row.from_name ? { name: row.from_name } : {} } : void 0);
+    const sendInput = {
+      to: input.to,
+      subject,
+      html,
+      text,
+      ...from ? { from } : {},
+      ...input.cc ? { cc: input.cc } : {},
+      ...input.bcc ? { bcc: input.bcc } : {},
+      ...input.replyTo ?? row.reply_to ? { replyTo: input.replyTo ?? row.reply_to } : {},
+      ...input.attachments ? { attachments: input.attachments } : {},
+      ...input.headers ? { headers: input.headers } : {},
+      ...input.relatedObject ? { relatedObject: input.relatedObject } : {},
+      ...input.relatedId ? { relatedId: input.relatedId } : {},
+      ...input.sentBy ? { sentBy: input.sentBy } : {}
+    };
+    return this.send(sendInput);
+  }
+};
+
+// src/transports/resend.ts
+var ResendTransport = class {
+  constructor(apiKeyOrOptions) {
+    if (typeof apiKeyOrOptions === "string") {
+      this.apiKey = apiKeyOrOptions;
+      this.endpoint = "https://api.resend.com/emails";
+    } else {
+      this.apiKey = apiKeyOrOptions.apiKey;
+      this.endpoint = apiKeyOrOptions.endpoint || "https://api.resend.com/emails";
+    }
+    if (!this.apiKey) {
+      throw new Error("ResendTransport: apiKey is required");
+    }
+  }
+  async send(message) {
+    const body = {
+      from: message.from,
+      to: message.to,
+      subject: message.subject
+    };
+    if (message.html !== void 0) body.html = message.html;
+    if (message.text !== void 0) body.text = message.text;
+    if (message.cc?.length) body.cc = message.cc;
+    if (message.bcc?.length) body.bcc = message.bcc;
+    if (message.replyTo) body.reply_to = message.replyTo;
+    if (message.headers && Object.keys(message.headers).length > 0) body.headers = message.headers;
+    if (message.attachments?.length) {
+      body.attachments = message.attachments.map((a) => ({
+        filename: a.filename,
+        content: typeof a.content === "string" ? a.content : a.content?.toString?.("base64") ?? String(a.content),
+        ...a.contentType ? { content_type: a.contentType } : {}
+      }));
+    }
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`Resend ${res.status}: ${errText.slice(0, 500)}`);
+    }
+    const json = await res.json().catch(() => ({}));
+    const messageId = String(json?.id ?? "");
+    if (!messageId) {
+      throw new Error("Resend: response missing `id` field");
+    }
+    return { messageId, response: "resend:ok" };
+  }
+};
+
+// src/transports/postmark.ts
+var PostmarkTransport = class {
+  constructor(opts) {
+    if (!opts?.apiKey) throw new Error("PostmarkTransport: apiKey is required");
+    this.apiKey = opts.apiKey;
+    this.endpoint = opts.endpoint || "https://api.postmarkapp.com/email";
+    this.messageStream = opts.messageStream || "outbound";
+  }
+  async send(message) {
+    const body = {
+      From: message.from,
+      To: message.to.join(", "),
+      Subject: message.subject,
+      MessageStream: this.messageStream
+    };
+    if (message.html !== void 0) body.HtmlBody = message.html;
+    if (message.text !== void 0) body.TextBody = message.text;
+    if (message.cc?.length) body.Cc = message.cc.join(", ");
+    if (message.bcc?.length) body.Bcc = message.bcc.join(", ");
+    if (message.replyTo) body.ReplyTo = message.replyTo;
+    if (message.headers && Object.keys(message.headers).length > 0) {
+      body.Headers = Object.entries(message.headers).map(([Name, Value]) => ({ Name, Value }));
+    }
+    if (message.attachments?.length) {
+      body.Attachments = message.attachments.map((a) => ({
+        Name: a.filename,
+        Content: typeof a.content === "string" ? a.content : a.content?.toString?.("base64") ?? String(a.content),
+        ContentType: a.contentType || "application/octet-stream",
+        ...a.cid ? { ContentID: `cid:${a.cid}` } : {}
+      }));
+    }
+    const res = await fetch(this.endpoint, {
+      method: "POST",
+      headers: {
+        "X-Postmark-Server-Token": this.apiKey,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errText = await res.text().catch(() => "");
+      throw new Error(`Postmark ${res.status}: ${errText.slice(0, 500)}`);
+    }
+    const json = await res.json().catch(() => ({}));
+    const messageId = String(json?.MessageID ?? "");
+    if (!messageId) {
+      throw new Error("Postmark: response missing `MessageID` field");
+    }
+    return { messageId, response: "postmark:ok" };
+  }
+};
+
+// src/transports/index.ts
+function makeTransport(opts) {
+  const { provider, apiKey, options = {}, logger } = opts;
+  switch (provider) {
+    case "log":
+      return new LogTransport(logger);
+    case "resend":
+      if (!apiKey) throw new Error("makeTransport: provider='resend' requires apiKey (OS_EMAIL_API_KEY)");
+      return new ResendTransport({ apiKey, ...options });
+    case "postmark":
+      if (!apiKey) throw new Error("makeTransport: provider='postmark' requires apiKey (OS_EMAIL_API_KEY)");
+      return new PostmarkTransport({ apiKey, ...options });
+    default:
+      throw new Error(`makeTransport: unknown provider '${provider}'`);
+  }
+}
+
+// src/templates/auth-templates.ts
+var baseStyles = "font-family:-apple-system,Segoe UI,Roboto,Helvetica,Arial,sans-serif;line-height:1.5;color:#1f2937";
+var buttonStyles = "display:inline-block;padding:12px 24px;background:#2563eb;color:#ffffff;text-decoration:none;border-radius:6px;font-weight:600";
+var footerStyles = "margin-top:32px;padding-top:16px;border-top:1px solid #e5e7eb;color:#6b7280;font-size:12px";
+function wrap(title, bodyHtml) {
+  return `<!doctype html><html><body style="${baseStyles};margin:0;padding:24px;background:#f9fafb">
+<div style="max-width:560px;margin:0 auto;background:#ffffff;padding:32px;border-radius:8px;border:1px solid #e5e7eb">
+<h1 style="margin:0 0 16px 0;font-size:20px;font-weight:600">${title}</h1>
+${bodyHtml}
+<div style="${footerStyles}">
+You received this email because of activity on your {{appName}} account.<br>
+If this wasn't you, you can safely ignore this message.
+</div>
+</div></body></html>`;
+}
+var AUTH_PASSWORD_RESET_TEMPLATE = {
+  name: "auth.password_reset",
+  label: "Password Reset",
+  category: "auth",
+  locale: "en-US",
+  subject: "Reset your {{appName}} password",
+  bodyHtml: wrap("Reset your password", `
+<p>Hi {{user.name}},</p>
+<p>We received a request to reset the password for the account associated with <strong>{{user.email}}</strong>.</p>
+<p>Click the button below to choose a new password. This link expires in {{expiresInMinutes}} minutes.</p>
+<p style="margin:24px 0"><a href="{{{resetUrl}}}" style="${buttonStyles}">Reset password</a></p>
+<p style="font-size:13px;color:#6b7280">Or copy and paste this URL into your browser:<br><span style="word-break:break-all">{{resetUrl}}</span></p>
+<p>If you didn't request this, no action is needed \u2014 your password stays the same.</p>
+`),
+  bodyText: `Hi {{user.name}},
+
+We received a request to reset the password for {{user.email}}.
+
+Reset your password (link expires in {{expiresInMinutes}} minutes):
+{{resetUrl}}
+
+If you didn't request this, ignore this email.`,
+  variables: [
+    { name: "user.name", type: "string", required: false, description: "Recipient display name" },
+    { name: "user.email", type: "string", required: true, description: "Recipient email" },
+    { name: "resetUrl", type: "url", required: true, description: "Password reset URL" },
+    { name: "expiresInMinutes", type: "number", required: false, description: "Link TTL in minutes" },
+    { name: "appName", type: "string", required: false, description: "Product/app name (brand override)" }
+  ],
+  active: true,
+  isSystem: true,
+  description: "Sent when a user requests a password reset via better-auth."
+};
+var AUTH_VERIFY_EMAIL_TEMPLATE = {
+  name: "auth.verify_email",
+  label: "Verify Email Address",
+  category: "auth",
+  locale: "en-US",
+  subject: "Verify your {{appName}} email address",
+  bodyHtml: wrap("Verify your email", `
+<p>Hi {{user.name}},</p>
+<p>Thanks for signing up for {{appName}}! Please confirm <strong>{{user.email}}</strong> belongs to you.</p>
+<p style="margin:24px 0"><a href="{{{verificationUrl}}}" style="${buttonStyles}">Verify email</a></p>
+<p style="font-size:13px;color:#6b7280">Or copy and paste this URL into your browser:<br><span style="word-break:break-all">{{verificationUrl}}</span></p>
+`),
+  bodyText: `Hi {{user.name}},
+
+Please verify your email ({{user.email}}) by opening this link:
+{{verificationUrl}}`,
+  variables: [
+    { name: "user.name", type: "string", required: false },
+    { name: "user.email", type: "string", required: true },
+    { name: "verificationUrl", type: "url", required: true },
+    { name: "appName", type: "string", required: false }
+  ],
+  active: true,
+  isSystem: true,
+  description: "Sent when better-auth needs to verify a newly-registered email address."
+};
+var AUTH_MAGIC_LINK_TEMPLATE = {
+  name: "auth.magic_link",
+  label: "Magic Link Sign-In",
+  category: "auth",
+  locale: "en-US",
+  subject: "Your {{appName}} sign-in link",
+  bodyHtml: wrap("Sign in to {{appName}}", `
+<p>Click the button below to sign in. This link expires in {{expiresInMinutes}} minutes and may only be used once.</p>
+<p style="margin:24px 0"><a href="{{{magicLinkUrl}}}" style="${buttonStyles}">Sign in</a></p>
+<p style="font-size:13px;color:#6b7280">Or paste:<br><span style="word-break:break-all">{{magicLinkUrl}}</span></p>
+`),
+  bodyText: `Sign in to {{appName}} (expires in {{expiresInMinutes}} min):
+{{magicLinkUrl}}`,
+  variables: [
+    { name: "magicLinkUrl", type: "url", required: true },
+    { name: "expiresInMinutes", type: "number", required: false },
+    { name: "appName", type: "string", required: false }
+  ],
+  active: true,
+  isSystem: true,
+  description: "Passwordless sign-in link sent by the magic-link plugin."
+};
+var AUTH_INVITATION_TEMPLATE = {
+  name: "auth.invitation",
+  label: "Organization Invitation",
+  category: "auth",
+  locale: "en-US",
+  subject: "{{inviter.name}} invited you to {{organization.name}}",
+  bodyHtml: wrap("You have been invited", `
+<p><strong>{{inviter.name}}</strong> ({{inviter.email}}) has invited you to join <strong>{{organization.name}}</strong> on {{appName}} as <em>{{role}}</em>.</p>
+<p style="margin:24px 0"><a href="{{{acceptUrl}}}" style="${buttonStyles}">Accept invitation</a></p>
+<p style="font-size:13px;color:#6b7280">Or paste:<br><span style="word-break:break-all">{{acceptUrl}}</span></p>
+`),
+  bodyText: `{{inviter.name}} ({{inviter.email}}) invited you to join {{organization.name}} on {{appName}}.
+
+Accept: {{acceptUrl}}`,
+  variables: [
+    { name: "inviter.name", type: "string", required: false },
+    { name: "inviter.email", type: "string", required: false },
+    { name: "organization.name", type: "string", required: true },
+    { name: "role", type: "string", required: false },
+    { name: "acceptUrl", type: "url", required: true },
+    { name: "appName", type: "string", required: false }
+  ],
+  active: true,
+  isSystem: true,
+  description: "Sent by better-auth organization plugin when a user is invited to an org."
+};
+var AUTH_TWO_FACTOR_OTP_TEMPLATE = {
+  name: "auth.two_factor_otp",
+  label: "Two-Factor Verification Code",
+  category: "auth",
+  locale: "en-US",
+  subject: "Your {{appName}} verification code",
+  bodyHtml: wrap("Your verification code", `
+<p>Use this code to complete sign-in:</p>
+<p style="font-size:32px;font-weight:700;letter-spacing:6px;background:#f3f4f6;padding:16px;text-align:center;border-radius:6px;margin:24px 0">{{otp}}</p>
+<p style="color:#6b7280;font-size:13px">This code expires in {{expiresInMinutes}} minutes. If you didn't try to sign in, change your password \u2014 your account may be at risk.</p>
+`),
+  bodyText: `Your {{appName}} verification code: {{otp}}
+(expires in {{expiresInMinutes}} minutes)`,
+  variables: [
+    { name: "otp", type: "string", required: true },
+    { name: "expiresInMinutes", type: "number", required: false },
+    { name: "appName", type: "string", required: false }
+  ],
+  active: true,
+  isSystem: true,
+  description: "Time-based OTP delivered for two-factor / email-OTP login."
+};
+var BUILTIN_AUTH_TEMPLATES = [
+  AUTH_PASSWORD_RESET_TEMPLATE,
+  AUTH_VERIFY_EMAIL_TEMPLATE,
+  AUTH_MAGIC_LINK_TEMPLATE,
+  AUTH_INVITATION_TEMPLATE,
+  AUTH_TWO_FACTOR_OTP_TEMPLATE
+];
+
+// src/email-plugin.ts
+var SYSTEM_CTX = { isSystem: true, roles: [], permissions: [] };
+var EmailServicePlugin = class {
+  constructor(options = {}) {
+    this.name = "com.objectstack.service.email";
+    this.version = "1.0.0";
+    this.type = "standard";
+    this.dependencies = ["com.objectstack.engine.objectql"];
+    this.options = options;
+  }
+  resolveTransport(ctx) {
+    if (this.options.transport) return this.options.transport;
+    const provider = this.options.provider ?? "log";
+    if (provider === "log") return new LogTransport(ctx.logger);
+    return makeTransport({
+      provider,
+      apiKey: this.options.apiKey,
+      options: this.options.providerOptions,
+      logger: ctx.logger
+    });
+  }
+  async init(ctx) {
+    ctx.getService("manifest").register({
+      id: "com.objectstack.service.email",
+      name: "Email Service",
+      version: "1.0.0",
+      type: "plugin",
+      scope: "system",
+      defaultDatasource: "cloud",
+      namespace: "sys",
+      objects: [SysEmail, SysEmailTemplate]
+    });
+    const transport = this.resolveTransport(ctx);
+    if (!this.options.transport && (this.options.provider ?? "log") === "log") {
+      ctx.logger.info(
+        "EmailServicePlugin: no transport configured \u2014 using LogTransport (mail will NOT be sent)"
+      );
+    } else {
+      ctx.logger.info(
+        `EmailServicePlugin: using '${this.options.provider ?? "log"}' provider`
+      );
+    }
+    this.service = new EmailService({
+      transport,
+      defaultFrom: this.options.defaultFrom,
+      retries: this.options.retries,
+      defaultTemplateContext: this.options.defaultTemplateContext,
+      logger: ctx.logger
+    });
+    ctx.registerService("email", this.service);
+    ctx.logger.info("EmailServicePlugin: email service registered");
+  }
+  async start(ctx) {
+    ctx.hook("kernel:ready", async () => {
+      let engine = null;
+      try {
+        engine = ctx.getService("objectql");
+      } catch {
+        try {
+          engine = ctx.getService("data");
+        } catch {
+        }
+      }
+      if (!engine || !this.service) return;
+      try {
+        const settings = ctx.getService("settings");
+        if (settings && typeof settings.createClient === "function") {
+          const applySettings = async () => {
+            try {
+              const payload = await settings.getNamespace("mail");
+              const values = {};
+              for (const [k, v] of Object.entries(payload.values)) {
+                values[k] = v?.value;
+              }
+              this.applyMailSettings(values, ctx);
+            } catch (err) {
+              ctx.logger.warn("EmailServicePlugin: failed to apply mail settings: " + (err?.message ?? err));
+            }
+          };
+          await applySettings();
+          if (typeof settings.subscribe === "function") {
+            settings.subscribe("mail", () => {
+              void applySettings();
+            });
+            ctx.logger.info("EmailServicePlugin: bound to settings:changed for namespace=mail");
+          }
+          if (typeof settings.registerAction === "function") {
+            const svc = this.service;
+            settings.registerAction("mail", "test", async ({ values, ctx: actionCtx }) => {
+              const to = actionCtx?.body?.to ?? values.from_email;
+              if (!to) {
+                return { ok: false, severity: "error", message: 'Provide a "to" address (or set from_email).' };
+              }
+              try {
+                const result = await svc.send({
+                  to,
+                  from: values.from_email ? {
+                    address: String(values.from_email),
+                    name: values.from_name ? String(values.from_name) : void 0
+                  } : void 0,
+                  subject: "ObjectStack mail test",
+                  text: "This is a test email from the ObjectStack settings page."
+                });
+                if (result.status === "failed") {
+                  return { ok: false, severity: "error", message: result.error ?? "Send failed." };
+                }
+                return {
+                  ok: true,
+                  severity: "info",
+                  message: `Sent test email to ${to} (id=${result.id}).`
+                };
+              } catch (err) {
+                return { ok: false, severity: "error", message: err?.message ?? String(err) };
+              }
+            });
+          }
+        }
+      } catch {
+      }
+      const persistence = this.options.persist === false ? void 0 : {
+        async insert(row) {
+          const created = await engine.insert("sys_email", row, {
+            context: SYSTEM_CTX
+          });
+          return created?.id ? { id: String(created.id) } : { id: String(row.id) };
+        },
+        async update(id, patch) {
+          await engine.update("sys_email", { id, ...patch }, {
+            context: SYSTEM_CTX
+          });
+        }
+      };
+      const templateLoader = {
+        async load(name, locale) {
+          const where = { name };
+          if (locale) where.locale = locale;
+          const rows = await engine.find("sys_email_template", {
+            where,
+            limit: 1,
+            context: SYSTEM_CTX
+          });
+          const row = Array.isArray(rows) ? rows[0] : rows?.data?.[0];
+          return row || null;
+        }
+      };
+      if (persistence) this.service.setPersistence(persistence);
+      this.service.setTemplateLoader(templateLoader);
+      ctx.logger.info("EmailServicePlugin: sys_email persistence + template loader enabled");
+      try {
+        const queue = ctx.getService("queue");
+        if (queue && typeof queue.subscribe === "function" && this.service) {
+          const svc = this.service;
+          await queue.subscribe("email.send.async", async (msg) => {
+            const result = await svc.send(msg.data);
+            if (result.status === "failed") {
+              throw new Error(result.error ?? "email send failed");
+            }
+          });
+          ctx.logger.info("EmailServicePlugin: subscribed to email.send.async queue");
+        }
+      } catch (err) {
+        ctx.logger.warn("EmailServicePlugin: email.send.async subscription failed", err);
+      }
+      if (this.options.seedTemplates !== false) {
+        const all = [
+          ...BUILTIN_AUTH_TEMPLATES,
+          ...this.options.templates ?? []
+        ];
+        for (const tpl of all) {
+          try {
+            await this.upsertTemplate(engine, tpl);
+          } catch (err) {
+            ctx.logger.warn(`EmailServicePlugin: seed template failed: ${tpl.name} ${tpl.locale}`, err?.message || err);
+          }
+        }
+        ctx.logger.info(`EmailServicePlugin: seeded ${all.length} template row(s)`);
+      }
+    });
+  }
+  /**
+   * Translate the `mail` settings namespace snapshot into a transport
+   * and `defaultFrom`, then hot-swap them on the running EmailService.
+   *
+   * Behaviour:
+   *  - `provider = 'log' | 'smtp'` keeps the LogTransport (real SMTP
+   *    delivery requires `@objectstack/plugin-mail-smtp`, which is not
+   *    a dependency of this package). The from-address is still applied.
+   *  - `provider = 'resend' | 'postmark'` rebuilds the transport using
+   *    `api_key` from settings. If `api_key` is missing the swap is
+   *    skipped and a warning is logged — the previous transport stays.
+   *
+   * Env-locked fields (handled in SettingsService.get) still resolve
+   * before this method ever sees them, so an env override transparently
+   * wins.
+   */
+  applyMailSettings(values, ctx) {
+    if (!this.service) return;
+    const fromEmail = typeof values.from_email === "string" ? values.from_email : void 0;
+    const fromName = typeof values.from_name === "string" ? values.from_name : void 0;
+    if (fromEmail) this.service.setDefaultFrom({ address: fromEmail, name: fromName });
+    const provider = String(values.provider ?? "smtp");
+    if (provider === "smtp" || provider === "log") {
+      ctx.logger.info(
+        `EmailServicePlugin: mail settings applied (provider=${provider}, from=${fromEmail ?? "\u2205"}); transport unchanged.`
+      );
+      return;
+    }
+    const apiKey = typeof values.api_key === "string" ? values.api_key : void 0;
+    if (!apiKey) {
+      ctx.logger.warn(
+        `EmailServicePlugin: provider='${provider}' selected but api_key is empty \u2014 transport NOT rebuilt.`
+      );
+      return;
+    }
+    try {
+      const transport = makeTransport({
+        provider,
+        apiKey,
+        logger: ctx.logger
+      });
+      this.service.setTransport(transport);
+      ctx.logger.info(`EmailServicePlugin: transport rebuilt from settings (provider=${provider}).`);
+    } catch (err) {
+      ctx.logger.warn("EmailServicePlugin: failed to rebuild transport: " + (err?.message ?? err));
+    }
+  }
+  async upsertTemplate(engine, tpl) {
+    const row = {
+      name: tpl.name,
+      label: tpl.label,
+      category: tpl.category,
+      locale: tpl.locale,
+      subject: tpl.subject,
+      body_html: tpl.bodyHtml,
+      ...tpl.bodyText ? { body_text: tpl.bodyText } : {},
+      ...tpl.fromOverride?.address ? {
+        from_address: tpl.fromOverride.address,
+        ...tpl.fromOverride.name ? { from_name: tpl.fromOverride.name } : {}
+      } : {},
+      ...tpl.replyTo ? { reply_to: tpl.replyTo } : {},
+      active: tpl.active,
+      is_system: tpl.isSystem,
+      ...tpl.description ? { description: tpl.description } : {},
+      ...tpl.variables?.length ? { variables_json: JSON.stringify(tpl.variables) } : {}
+    };
+    const existing = await engine.find("sys_email_template", {
+      where: { name: tpl.name, locale: tpl.locale },
+      limit: 1,
+      context: SYSTEM_CTX
+    });
+    const existingRow = Array.isArray(existing) ? existing[0] : existing?.data?.[0];
+    if (existingRow?.id) {
+      if (existingRow.is_system === false) return;
+      await engine.update("sys_email_template", { id: existingRow.id, ...row }, {
+        context: SYSTEM_CTX
+      });
+    } else {
+      await engine.insert("sys_email_template", row, {
+        context: SYSTEM_CTX
+      });
+    }
+  }
+};
+export {
+  AUTH_INVITATION_TEMPLATE,
+  AUTH_MAGIC_LINK_TEMPLATE,
+  AUTH_PASSWORD_RESET_TEMPLATE,
+  AUTH_TWO_FACTOR_OTP_TEMPLATE,
+  AUTH_VERIFY_EMAIL_TEMPLATE,
+  BUILTIN_AUTH_TEMPLATES,
+  EmailServicePlugin,
+  LogTransport,
+  PostmarkTransport,
+  ResendTransport,
+  formatAddress,
+  htmlToText,
+  makeTransport,
+  normalizeMessage,
+  renderTemplate,
+  requireVars
+};
+//# sourceMappingURL=index.mjs.map