@bygghammar/cms-platform 0.36.0 → 0.37.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # Changelog
 
+## 0.37.0
+
+- Added `server/forms-delivery-core` — the full form submission delivery stack
+  (email provider resolution, smart-tag template rendering, admin notification,
+  autoreply, email logging, Google Sheets append and signed outbound webhook) is
+  now shared. A site keeps only a thin adapter that supplies its privileged
+  database client.
+
+## 0.36.0
+
+- New server cores: `server/provider-secrets`, `server/smtp` and
+  `server/email-send-core`. Provider credential resolution, the raw-socket
+  STARTTLS SMTP client and all provider transports (Mailgun, Amazon SES, HTTP
+  endpoint, SMTP) are now shared, so a site keeps only re-export adapters.
+
 ## 0.35.0
 
 - Added `tracking/injections` — the pure "Code & tracking" helpers (profile

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.36.0",
+  "version": "0.37.0",
   "description": "Shared CMS platform: blocks, block types, i18n core, UI primitives and design-token contract used by every Bygghammar/Voyara site.",
   "type": "module",
   "sideEffects": false,
@@ -151,7 +151,8 @@
     "./server/domains-core": "./src/server/domains-core.ts",
     "./server/provider-secrets": "./src/server/provider-secrets.ts",
     "./server/smtp": "./src/server/smtp.ts",
-    "./server/email-send-core": "./src/server/email-send-core.ts"
+    "./server/email-send-core": "./src/server/email-send-core.ts",
+    "./server/forms-delivery-core": "./src/server/forms-delivery-core.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/server/forms-delivery-core.ts

@@ -0,0 +1,504 @@
+/**
+ * Host-agnostic delivery side effects for form submissions: admin
+ * notification email, autoreply to the submitter, Google Sheets append and
+ * outbound webhook.
+ *
+ * Never throws — every function reports failure back so the submission itself
+ * is always kept (submissions are append-only, customer data first).
+ *
+ * The host injects a privileged database client; everything else (provider
+ * resolution, template rendering, email logging) is shared.
+ *
+ * Server-only. Never import from client code.
+ */
+
+import type { FormFieldDef } from "../forms/field-sets";
+import { sendViaProvider } from "./email-send-core";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Structural subset of a Supabase-shaped privileged client. */
+export type DeliveryDb = { from: (table: string) => any };
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+export type DeliveryResult = { ok: boolean; error?: string };
+
+type ResolvedProvider = {
+  id: string;
+  name: string;
+  kind: string;
+  fromName: string | null;
+  fromEmail: string;
+  replyTo: string | null;
+};
+
+type ProviderRow = {
+  id: string;
+  name: string;
+  kind: string;
+  from_name: string | null;
+  from_email: string | null;
+  reply_to: string | null;
+  config: Record<string, unknown> | null;
+  secret_ref_name: string | null;
+  is_active?: boolean | null;
+  sort_order?: number | null;
+};
+
+/** Resolve the default (or first active) email provider plus sender identity. */
+export async function resolveDeliveryProvider(
+  db: DeliveryDb,
+): Promise<
+  { ok: true; provider: ResolvedProvider; raw: ProviderRow } | { ok: false; error: string }
+> {
+  const { data: settings } = await db
+    .from("email_settings")
+    .select("*")
+    .eq("id", true)
+    .maybeSingle();
+
+  let raw: ProviderRow | null = null;
+  if (settings?.default_provider_id) {
+    const { data } = await db
+      .from("email_providers")
+      .select("*")
+      .eq("id", settings.default_provider_id)
+      .maybeSingle();
+    raw = (data ?? null) as ProviderRow | null;
+  }
+  if (!raw) {
+    const { data } = await db
+      .from("email_providers")
+      .select("*")
+      .eq("is_active", true)
+      .order("sort_order", { ascending: true })
+      .limit(1);
+    raw = ((data as ProviderRow[] | null)?.[0] ?? null) as ProviderRow | null;
+  }
+  if (!raw) return { ok: false, error: "No active email provider configured." };
+
+  const fromEmail = raw.from_email ?? settings?.primary_from_email ?? null;
+  if (!fromEmail) return { ok: false, error: "No from address configured." };
+
+  return {
+    ok: true,
+    raw,
+    provider: {
+      id: raw.id,
+      name: raw.name,
+      kind: raw.kind,
+      fromName: raw.from_name ?? settings?.primary_from_name ?? null,
+      fromEmail,
+      replyTo: raw.reply_to ?? settings?.reply_to ?? null,
+    },
+  };
+}
+
+type SenderOverride = {
+  fromName?: string | null;
+  fromEmail?: string | null;
+  replyTo?: string | null;
+};
+
+async function dispatch(
+  db: DeliveryDb,
+  raw: ProviderRow,
+  provider: ResolvedProvider,
+  msg: { to: string; subject: string; html: string; text: string; replyTo: string | null },
+  meta: Record<string, unknown>,
+  from: SenderOverride = {},
+): Promise<DeliveryResult> {
+  const fromName = (from.fromName ?? "").trim() || provider.fromName;
+  const fromEmail = (from.fromEmail ?? "").trim() || provider.fromEmail;
+
+  const result = await sendViaProvider(
+    {
+      id: provider.id,
+      name: provider.name,
+      kind: provider.kind,
+      from_name: fromName,
+      from_email: fromEmail,
+      reply_to: msg.replyTo,
+      config: (raw.config ?? {}) as Record<string, unknown>,
+      secret_ref_name: raw.secret_ref_name,
+    },
+    {
+      to: msg.to,
+      subject: msg.subject,
+      html: msg.html,
+      text: msg.text,
+      fromName,
+      fromEmail,
+      replyTo: msg.replyTo,
+    },
+  );
+
+  await db.from("email_logs").insert({
+    to_address: msg.to,
+    from_address: fromEmail,
+    reply_to: msg.replyTo,
+    subject: msg.subject,
+    body_preview: msg.text.slice(0, 200),
+    provider: provider.name,
+    status: result.ok ? "sent" : "failed",
+    error: result.ok ? null : result.error,
+    meta: { ...meta, kind: provider.kind },
+  });
+
+  return result.ok ? { ok: true } : { ok: false, error: result.error };
+}
+
+const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+
+const labelOf = (fld: FormFieldDef) => fld.label.sv ?? fld.label.en ?? fld.key;
+
+/** Replace {{field_key}} placeholders with submitted values. */
+export function renderTemplate(
+  input: string,
+  payload: Record<string, string>,
+  extra: Record<string, string> = {},
+): string {
+  const all = { ...payload, ...extra };
+  return input.replace(/\{\{\s*([a-zA-Z0-9_.-]+)\s*\}\}/g, (_m, key: string) => all[key] ?? "");
+}
+
+/** Context tokens available to every notification/autoreply template. */
+export type TokenContext = {
+  formName: string;
+  formKey: string;
+  locale?: string;
+  pagePath?: string | null;
+  submissionId?: string | null;
+  ip?: string | null;
+  userAgent?: string | null;
+  referrer?: string | null;
+  /** Absolute origin of the site, used to build page_url / admin_url. */
+  siteUrl?: string | null;
+  /** Backoffice base path, defaults to `/kontoret`. */
+  backofficePath?: string;
+};
+
+/** Tokens every notification/autoreply template can use besides field keys. */
+export function templateTokens(opts: TokenContext): Record<string, string> {
+  const origin = (opts.siteUrl ?? "").replace(/\/+$/, "");
+  const path = opts.pagePath ?? "";
+  const base = (opts.backofficePath ?? "/kontoret").replace(/\/+$/, "");
+  const adminUrl = origin
+    ? `${origin}${base}/forms/submissions?form=${encodeURIComponent(opts.formKey)}${
+        opts.submissionId ? `&q=${encodeURIComponent(opts.submissionId)}` : ""
+      }`
+    : "";
+  return {
+    form: opts.formName,
+    form_name: opts.formName,
+    form_key: opts.formKey,
+    locale: opts.locale ?? "",
+    page: path,
+    page_url: origin && path ? `${origin}${path.startsWith("/") ? "" : "/"}${path}` : "",
+    admin_url: adminUrl,
+    ip: opts.ip ?? "",
+    user_agent: opts.userAgent ?? "",
+    referrer: opts.referrer ?? "",
+    date: new Date().toLocaleString("sv-SE"),
+    submission_id: opts.submissionId ?? "",
+  };
+}
+
+const EMAIL_TOKEN_RE = /^[^@\s]+@[^@\s]+\.[^@\s]+$/;
+
+/** Render smart tags inside a single-line header value (sender name, reply-to). */
+export function renderHeader(
+  input: string | undefined,
+  payload: Record<string, string>,
+  tokens: Record<string, string>,
+): string {
+  return renderTemplate((input ?? "").trim(), payload, tokens)
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+const TABLE_TOKEN = "\u0000FIELDS_TABLE\u0000";
+
+/** Every alias that expands to the full answer table. */
+const tableTokens = (value: string): Record<string, string> => ({
+  fields_table: value,
+  all_fields: value,
+  all_answers: value,
+});
+
+function answerRows(fields: FormFieldDef[], payload: Record<string, string>) {
+  return fields
+    .filter((fl) => fl.enabled)
+    .map((fl) => [labelOf(fl), payload[fl.key] ?? ""] as const)
+    .filter(([, v]) => v !== "");
+}
+
+function tableHtml(rows: readonly (readonly [string, string])[]) {
+  return `<table style="font-family:Arial,sans-serif;border-collapse:collapse">
+${rows
+  .map(
+    ([k, v]) =>
+      `<tr><td style="padding:4px 12px 4px 0;color:#666;vertical-align:top">${esc(k)}</td><td style="padding:4px 0">${esc(v).replace(/\n/g, "<br>")}</td></tr>`,
+  )
+  .join("")}
+</table>`;
+}
+
+export type NotifyOptions = TokenContext & {
+  to: string;
+  locale: string;
+  fields: FormFieldDef[];
+  payload: Record<string, string>;
+  /** Optional custom templates; empty falls back to the standard layout. */
+  subject?: string;
+  body?: string;
+  fromName?: string;
+  fromEmail?: string;
+  replyTo?: string;
+};
+
+/** Admin notification email for a new submission (one mail per recipient). */
+export async function notifySubmissionCore(
+  db: DeliveryDb,
+  opts: NotifyOptions,
+): Promise<DeliveryResult> {
+  const recipients = Array.from(
+    new Set(
+      opts.to
+        .split(/[,;\s]+/)
+        .map((s) => s.trim().toLowerCase())
+        .filter((s) => s.includes("@")),
+    ),
+  );
+  if (recipients.length === 0) return { ok: true };
+
+  const resolved = await resolveDeliveryProvider(db);
+  if (!resolved.ok) return { ok: false, error: resolved.error };
+
+  const rows = answerRows(opts.fields, opts.payload);
+  const tokens = templateTokens(opts);
+  const plainTable = rows.map(([k, v]) => `${k}: ${v}`).join("\n");
+  const escapedPayload = Object.fromEntries(
+    Object.entries(opts.payload).map(([k, v]) => [k, esc(v)]),
+  );
+
+  // Smart tags are allowed in the sender name and reply-to; an unusable
+  // reply-to falls back to the submitter's address, then the provider default.
+  const renderedReplyTo = renderHeader(opts.replyTo, opts.payload, tokens);
+  const replyTo = EMAIL_TOKEN_RE.test(renderedReplyTo)
+    ? renderedReplyTo
+    : opts.payload.email?.includes("@")
+      ? opts.payload.email
+      : resolved.provider.replyTo;
+  const fromName = renderHeader(opts.fromName, opts.payload, tokens) || undefined;
+
+  const subjectTpl = (opts.subject ?? "").trim();
+  const subject = subjectTpl
+    ? renderTemplate(subjectTpl, opts.payload, { ...tokens, ...tableTokens(plainTable) }).trim() ||
+      `${opts.formName}: new submission`
+    : `${opts.formName}: new submission`;
+
+  const bodyTpl = (opts.body ?? "").trim();
+  let text: string;
+  let html: string;
+
+  if (bodyTpl) {
+    text = renderTemplate(bodyTpl, opts.payload, { ...tokens, ...tableTokens(plainTable) });
+    const htmlSource = renderTemplate(esc(bodyTpl), escapedPayload, {
+      ...Object.fromEntries(Object.entries(tokens).map(([k, v]) => [k, esc(v)])),
+      ...tableTokens(TABLE_TOKEN),
+    });
+    html = `<div style="font-family:Arial,sans-serif;font-size:15px;line-height:1.6;color:#111">${htmlSource
+      .replace(/\n/g, "<br>")
+      .replace(TABLE_TOKEN, tableHtml(rows))}</div>`;
+  } else {
+    text = [
+      `Form: ${opts.formName} (${opts.formKey})`,
+      `Language: ${opts.locale}`,
+      opts.pagePath ? `Page: ${opts.pagePath}` : "",
+      "",
+      plainTable,
+    ]
+      .filter(Boolean)
+      .join("\n");
+    html = `<h2 style="font-family:Arial,sans-serif">${esc(opts.formName)}</h2>
+${tableHtml(rows)}
+<p style="font-family:Arial,sans-serif;color:#888;font-size:12px">${esc(opts.formKey)} · ${esc(opts.locale)}${opts.pagePath ? ` · ${esc(opts.pagePath)}` : ""}</p>`;
+  }
+
+  let lastError: string | undefined;
+  let anyOk = false;
+  for (const to of recipients) {
+    const res = await dispatch(
+      db,
+      resolved.raw,
+      resolved.provider,
+      { to, subject, html, text, replyTo },
+      { form_key: opts.formKey, purpose: "form_notification" },
+      { fromName, fromEmail: opts.fromEmail },
+    );
+    if (res.ok) anyOk = true;
+    else lastError = res.error;
+  }
+  return anyOk ? { ok: true } : { ok: false, error: lastError };
+}
+
+export type AutoreplyOptions = TokenContext & {
+  to: string;
+  subject: string;
+  body: string;
+  payload: Record<string, string>;
+  /** Optional — enables the {{all_fields}} answer table. */
+  fields?: FormFieldDef[];
+  fromName?: string;
+  fromEmail?: string;
+  replyTo?: string;
+};
+
+/** Confirmation email back to the person who submitted the form. */
+export async function sendAutoreplyCore(
+  db: DeliveryDb,
+  opts: AutoreplyOptions,
+): Promise<DeliveryResult> {
+  const to = opts.to.trim();
+  if (!to || !EMAIL_TOKEN_RE.test(to)) {
+    return { ok: false, error: "No valid email address in the submission." };
+  }
+  const rows = answerRows(opts.fields ?? [], opts.payload);
+  const plainTable = rows.map(([k, v]) => `${k}: ${v}`).join("\n");
+  const tokens = { ...templateTokens(opts), ...tableTokens(plainTable) };
+  const subject = renderTemplate(opts.subject, opts.payload, tokens).trim();
+  const body = renderTemplate(opts.body, opts.payload, tokens).trim();
+  if (!subject || !body) return { ok: false, error: "Autoreply subject or body is empty." };
+
+  const resolved = await resolveDeliveryProvider(db);
+  if (!resolved.ok) return { ok: false, error: resolved.error };
+
+  const html = `<div style="font-family:Arial,sans-serif;font-size:15px;line-height:1.6;color:#111">${esc(
+    body,
+  ).replace(/\n/g, "<br>")}</div>`;
+
+  const renderedReplyTo = renderHeader(opts.replyTo, opts.payload, tokens);
+  const fromName = renderHeader(opts.fromName, opts.payload, tokens) || undefined;
+
+  return dispatch(
+    db,
+    resolved.raw,
+    resolved.provider,
+    {
+      to,
+      subject,
+      html,
+      text: body,
+      replyTo: EMAIL_TOKEN_RE.test(renderedReplyTo) ? renderedReplyTo : resolved.provider.replyTo,
+    },
+    { form_key: opts.formKey, purpose: "form_autoreply" },
+    { fromName, fromEmail: opts.fromEmail },
+  );
+}
+
+const GATEWAY = "https://connector-gateway.lovable.dev/google_sheets/v4";
+
+/** Append one submission row to a Google Sheet via the connector gateway. */
+export async function appendToSheetCore(opts: {
+  sheetId: string;
+  tab: string;
+  values: string[];
+}): Promise<DeliveryResult> {
+  const lovableKey = process.env['LOVABLE_API_KEY'];
+  const connKey = process.env['GOOGLE_SHEETS_API_KEY'];
+  if (!opts.sheetId) return { ok: false, error: "No Google Sheet configured." };
+  if (!lovableKey || !connKey)
+    return { ok: false, error: "Google Sheets is not connected for this project." };
+
+  const tab = opts.tab?.trim() || "Sheet1";
+  const range = `${tab}!A:Z`;
+  const res = await fetch(
+    `${GATEWAY}/spreadsheets/${opts.sheetId}/values/${range}:append?valueInputOption=USER_ENTERED&insertDataOption=INSERT_ROWS`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${lovableKey}`,
+        "X-Connection-Api-Key": connKey,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ values: [opts.values] }),
+    },
+  );
+  if (!res.ok) {
+    const body = await res.text();
+    console.error(`[forms] sheets append failed [${res.status}]: ${body}`);
+    return { ok: false, error: `Google Sheets [${res.status}]: ${body.slice(0, 300)}` };
+  }
+  return { ok: true };
+}
+
+/**
+ * POST one submission to an external endpoint (CRM, Zapier, Make…).
+ * Signed with an optional shared secret so the receiver can verify origin.
+ * Never throws: the submission is already stored and must never be lost.
+ */
+export async function postWebhookCore(opts: {
+  url: string;
+  secret?: string | null;
+  formKey: string;
+  formName: string;
+  submissionId: string;
+  locale: string;
+  pagePath?: string | null;
+  createdAt: string;
+  payload: Record<string, string>;
+  timeoutMs?: number;
+}): Promise<DeliveryResult & { status?: number }> {
+  const url = (opts.url ?? "").trim();
+  if (!url) return { ok: false, error: "No webhook URL configured." };
+  if (!/^https:\/\//i.test(url))
+    return { ok: false, error: "Webhook URL must start with https://" };
+
+  const body = JSON.stringify({
+    event: "form.submission",
+    form: { key: opts.formKey, name: opts.formName },
+    submission: {
+      id: opts.submissionId,
+      locale: opts.locale,
+      page_path: opts.pagePath ?? null,
+      created_at: opts.createdAt,
+      payload: opts.payload,
+    },
+  });
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-Form-Key": opts.formKey,
+    "X-Submission-Id": opts.submissionId,
+  };
+  const secret = (opts.secret ?? "").trim();
+  if (secret) {
+    try {
+      const { createHmac } = await import("crypto");
+      headers["X-Signature"] = createHmac("sha256", secret).update(body).digest("hex");
+    } catch {
+      /* signing unavailable — send unsigned rather than dropping the delivery */
+    }
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? 10_000);
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers,
+      body,
+      signal: controller.signal,
+    });
+    if (!res.ok) {
+      const text = (await res.text().catch(() => "")).slice(0, 300);
+      return { ok: false, status: res.status, error: `Webhook [${res.status}]: ${text}` };
+    }
+    return { ok: true, status: res.status };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    return { ok: false, error: msg === "The operation was aborted." ? "Webhook timed out." : msg };
+  } finally {
+    clearTimeout(timer);
+  }
+}