@bygghammar/cms-platform 0.34.1 → 0.36.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.35.0
+
+- Added `tracking/injections` — the pure "Code & tracking" helpers (profile
+  merging, scope selection, GTM/GA4/Meta/TikTok snippet builders).
+- Added `server/injections-core` — staff/admin CRUD for `site_injections` with a
+  host-supplied audit writer, plus cached request-time bundle resolution,
+  `isInjectablePath` and `applyInjections`.
+- Added `server/domains-core` — `locale_domains` reads, request-locale and
+  admin-domain resolution (with self-host `SITE_URL` precedence) and staff-only
+  upsert/delete.
+
 ## 0.34.1
 
 - `saveContentSectionCore` accepts an optional `data` payload, matching hosts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.34.1",
+  "version": "0.36.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,
@@ -145,7 +145,13 @@
     "./server/pages-core": "./src/server/pages-core.ts",
     "./server/resolve-globals": "./src/server/resolve-globals.ts",
     "./server/content-sections-core": "./src/server/content-sections-core.ts",
-    "./server/translate-db-core": "./src/server/translate-db-core.ts"
+    "./server/translate-db-core": "./src/server/translate-db-core.ts",
+    "./tracking/injections": "./src/tracking/injections.ts",
+    "./server/injections-core": "./src/server/injections-core.ts",
+    "./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"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/server/domains-core.ts

@@ -0,0 +1,180 @@
+/**
+ * Host-agnostic logic for locale → domain mapping (`locale_domains`).
+ *
+ * Reads use a privileged client because the table reveals which hostname serves
+ * the backoffice; writes run as the signed-in staff user. The host owns the
+ * server functions, its locale union and the request headers.
+ */
+
+import { assertStaff, type PlatformAuthContext } from "./guards";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/** Structural subset of a Supabase-shaped client used by this core. */
+export type DomainsClient = { from: (table: string) => any };
+/* eslint-enable @typescript-eslint/no-explicit-any */
+
+export type LocaleDomainRecord = {
+  locale: string;
+  domain: string;
+  isDefault: boolean;
+  isAdminDomain: boolean;
+};
+
+/** Strip protocol, trailing slashes and casing from a stored domain. */
+export function normalizeDomain(domain: string): string {
+  return domain
+    .replace(/^https?:\/\//, "")
+    .replace(/\/+$/, "")
+    .toLowerCase();
+}
+
+/** Strip a leading `www.` and casing from a request host. */
+export function normalizeHost(host: string): string {
+  return host.replace(/^www\./, "").toLowerCase();
+}
+
+function rowToDomain(row: {
+  locale: string;
+  domain: string;
+  is_default: boolean;
+  is_admin_domain: boolean;
+}): LocaleDomainRecord {
+  return {
+    locale: row.locale,
+    domain: row.domain,
+    isDefault: row.is_default,
+    isAdminDomain: row.is_admin_domain,
+  };
+}
+
+/** Every configured mapping, ordered by locale. Requires a privileged client. */
+export async function listLocaleDomainsCore(client: DomainsClient): Promise<LocaleDomainRecord[]> {
+  const { data, error } = await client
+    .from("locale_domains")
+    .select("locale, domain, is_default, is_admin_domain")
+    .order("locale");
+  if (error) throw new Error(error.message);
+  return (data ?? []).map(rowToDomain);
+}
+
+/** The mapping whose domain matches `host`, ignoring protocol and `www.`. */
+export function matchDomain(
+  domains: LocaleDomainRecord[],
+  host: string,
+): LocaleDomainRecord | undefined {
+  const normalizedHost = normalizeHost(host);
+  return domains.find((d) => {
+    const normalized = normalizeDomain(d.domain);
+    return normalizedHost === normalized || normalizedHost === `www.${normalized}`;
+  });
+}
+
+/**
+ * Resolve the active locale for a request host, falling back to the default
+ * mapping, then to the first mapping, then to a synthetic host-based record.
+ */
+export function resolveRequestLocale(
+  domains: LocaleDomainRecord[],
+  host: string,
+  defaultLocale: string,
+): { locale: string; domain: LocaleDomainRecord } {
+  const match = matchDomain(domains, host);
+  if (match) return { locale: match.locale, domain: match };
+
+  const fallback = domains.find((d) => d.isDefault) ??
+    domains[0] ?? {
+      locale: defaultLocale,
+      domain: host || "localhost",
+      isDefault: true,
+      isAdminDomain: true,
+    };
+  return { locale: fallback.locale, domain: fallback };
+}
+
+/**
+ * The domain that serves the backoffice.
+ *
+ * `forcedHost` (a self-host `SITE_URL`) is authoritative: an imported row from
+ * another deployment must never send the backoffice to that other hostname.
+ * Otherwise the flagged database row wins, and the request host is last resort.
+ */
+export function resolveAdminDomain(
+  domains: LocaleDomainRecord[],
+  options: { forcedHost?: string | null; requestHost?: string | null; defaultLocale: string },
+): LocaleDomainRecord {
+  const dbAdmin = domains.find((d) => d.isAdminDomain) ?? domains[0];
+
+  if (options.forcedHost) {
+    return {
+      locale: dbAdmin?.locale ?? options.defaultLocale,
+      domain: options.forcedHost,
+      isDefault: dbAdmin?.isDefault ?? true,
+      isAdminDomain: true,
+    };
+  }
+  if (dbAdmin) return dbAdmin;
+  return {
+    locale: options.defaultLocale,
+    domain: options.requestHost || "localhost",
+    isDefault: true,
+    isAdminDomain: true,
+  };
+}
+
+/** Absolute origin for a locale, or "" when the locale has no mapping. */
+export function resolveLocaleOrigin(locale: string, domains: LocaleDomainRecord[]): string {
+  const match = domains.find((d) => d.locale === locale);
+  if (!match) return "";
+  return `https://${normalizeDomain(match.domain)}`;
+}
+
+/**
+ * Staff-only upsert of one mapping. Keeps at most one default and one admin
+ * domain by clearing the flags on every other locale first.
+ */
+export async function saveLocaleDomainCore(
+  context: PlatformAuthContext & { supabase: DomainsClient },
+  input: { locale: string; domain: string; isDefault: boolean; isAdminDomain: boolean },
+  options: { invalidDomainMessage?: string } = {},
+): Promise<{ ok: true }> {
+  await assertStaff(context);
+
+  const normalized = normalizeDomain(input.domain);
+  if (!normalized) throw new Error(options.invalidDomainMessage ?? "Invalid domain");
+
+  if (input.isDefault) {
+    await context.supabase
+      .from("locale_domains")
+      .update({ is_default: false })
+      .neq("locale", input.locale);
+  }
+  if (input.isAdminDomain) {
+    await context.supabase
+      .from("locale_domains")
+      .update({ is_admin_domain: false })
+      .neq("locale", input.locale);
+  }
+
+  const { error } = await context.supabase.from("locale_domains").upsert(
+    {
+      locale: input.locale,
+      domain: normalized,
+      is_default: input.isDefault,
+      is_admin_domain: input.isAdminDomain,
+    },
+    { onConflict: "locale" },
+  );
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}
+
+/** Staff-only delete of one mapping. */
+export async function deleteLocaleDomainCore(
+  context: PlatformAuthContext & { supabase: DomainsClient },
+  locale: string,
+): Promise<{ ok: true }> {
+  await assertStaff(context);
+  const { error } = await context.supabase.from("locale_domains").delete().eq("locale", locale);
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}

package/src/server/email-send-core.ts

@@ -0,0 +1,266 @@
+/**
+ * Host-agnostic email dispatch for rows in `public.email_providers`.
+ *
+ * Each provider is dispatched by its `kind` (mailgun, ses, http, smtp). The
+ * credential is always resolved through the provider's preserved
+ * `secret_ref_name` environment variable — values are never read from the
+ * database and never appear in an error message.
+ *
+ * Server-only. Never import from client code.
+ */
+
+import { resolveProviderSecret, type Env } from "./provider-secrets";
+import { sendSmtp } from "./smtp";
+
+export type SendableProvider = {
+  id: string;
+  name: string;
+  kind: string;
+  from_name: string | null;
+  from_email: string | null;
+  reply_to: string | null;
+  config: Record<string, unknown>;
+  secret_ref_name: string | null;
+};
+
+export type SendResult = { ok: true } | { ok: false; error: string };
+
+export type SendPayload = {
+  to: string;
+  subject: string;
+  html: string;
+  text: string;
+  fromName: string | null;
+  fromEmail: string;
+  replyTo: string | null;
+};
+
+export type SendOptions = {
+  /** Environment used for credential lookup. Defaults to `process.env`. */
+  env?: Env;
+};
+
+function envOf(options?: SendOptions): Env {
+  return options?.env ?? (process.env as Env);
+}
+
+function secretOf(provider: SendableProvider, env: Env): string | undefined {
+  const res = resolveProviderSecret(provider, env);
+  return res.ok ? res.value : undefined;
+}
+
+/** Value-free explanation of why a provider credential is unavailable. */
+function secretProblem(provider: SendableProvider, env: Env): string {
+  const res = resolveProviderSecret(provider, env);
+  return res.ok ? "" : res.error;
+}
+
+function str(config: Record<string, unknown>, key: string): string | undefined {
+  const v = config?.[key];
+  return typeof v === "string" && v.trim() ? v.trim() : undefined;
+}
+
+function formatFrom(payload: SendPayload) {
+  return payload.fromName ? `${payload.fromName} <${payload.fromEmail}>` : payload.fromEmail;
+}
+
+/* ---------------- Mailgun ---------------- */
+async function sendMailgun(
+  p: SendableProvider,
+  payload: SendPayload,
+  env: Env,
+): Promise<SendResult> {
+  const domain = str(p.config, "domain");
+  const key = secretOf(p, env);
+  if (!domain) return { ok: false, error: "Mailgun domain is missing in the provider config." };
+  if (!key) return { ok: false, error: secretProblem(p, env) };
+  const region = (str(p.config, "region") ?? "us").toLowerCase();
+  const base =
+    str(p.config, "base_url") ??
+    (region.startsWith("eu") ? "https://api.eu.mailgun.net/v3" : "https://api.mailgun.net/v3");
+  const body = new URLSearchParams({
+    from: formatFrom(payload),
+    to: payload.to,
+    subject: payload.subject,
+    text: payload.text,
+    html: payload.html,
+  });
+  if (payload.replyTo) body.set("h:Reply-To", payload.replyTo);
+
+  const res = await fetch(`${base.replace(/\/$/, "")}/${domain}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Basic ${btoa(`api:${key}`)}`,
+      "Content-Type": "application/x-www-form-urlencoded",
+    },
+    body,
+  });
+  if (!res.ok) return { ok: false, error: `Mailgun [${res.status}]: ${await res.text()}` };
+  return { ok: true };
+}
+
+/* ---------------- Amazon SES (v2 HTTPS API, SigV4) ---------------- */
+const enc = new TextEncoder();
+
+async function hmac(key: ArrayBuffer | Uint8Array, data: string): Promise<ArrayBuffer> {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key as BufferSource,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"],
+  );
+  return crypto.subtle.sign("HMAC", cryptoKey, enc.encode(data));
+}
+
+function hex(buf: ArrayBuffer): string {
+  return Array.from(new Uint8Array(buf))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+async function sha256Hex(data: string): Promise<string> {
+  return hex(await crypto.subtle.digest("SHA-256", enc.encode(data)));
+}
+
+async function sendSes(p: SendableProvider, payload: SendPayload, env: Env): Promise<SendResult> {
+  const region = str(p.config, "region");
+  const accessKeyId = str(p.config, "access_key_id");
+  const secretAccessKey = secretOf(p, env);
+  if (!region) return { ok: false, error: "SES region is missing in the provider config." };
+  if (!accessKeyId)
+    return { ok: false, error: "SES access key id is missing in the provider config." };
+  if (!secretAccessKey) return { ok: false, error: secretProblem(p, env) };
+
+  const host = `email.${region}.amazonaws.com`;
+  const path = "/v2/email/outbound-emails";
+  const body = JSON.stringify({
+    FromEmailAddress: formatFrom(payload),
+    Destination: { ToAddresses: [payload.to] },
+    ...(payload.replyTo ? { ReplyToAddresses: [payload.replyTo] } : {}),
+    Content: {
+      Simple: {
+        Subject: { Data: payload.subject, Charset: "UTF-8" },
+        Body: {
+          Text: { Data: payload.text, Charset: "UTF-8" },
+          Html: { Data: payload.html, Charset: "UTF-8" },
+        },
+      },
+    },
+  });
+
+  const now = new Date();
+  const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, "");
+  const dateStamp = amzDate.slice(0, 8);
+  const payloadHash = await sha256Hex(body);
+  const canonicalHeaders = `content-type:application/json\nhost:${host}\nx-amz-content-sha256:${payloadHash}\nx-amz-date:${amzDate}\n`;
+  const signedHeaders = "content-type;host;x-amz-content-sha256;x-amz-date";
+  const canonicalRequest = `POST\n${path}\n\n${canonicalHeaders}\n${signedHeaders}\n${payloadHash}`;
+  const scope = `${dateStamp}/${region}/ses/aws4_request`;
+  const stringToSign = `AWS4-HMAC-SHA256\n${amzDate}\n${scope}\n${await sha256Hex(canonicalRequest)}`;
+
+  let signingKey: ArrayBuffer | Uint8Array = enc.encode(`AWS4${secretAccessKey}`);
+  for (const part of [dateStamp, region, "ses", "aws4_request"]) {
+    signingKey = await hmac(signingKey, part);
+  }
+  const signature = hex(await hmac(signingKey, stringToSign));
+
+  const res = await fetch(`https://${host}${path}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-Amz-Date": amzDate,
+      "x-amz-content-sha256": payloadHash,
+      Authorization: `AWS4-HMAC-SHA256 Credential=${accessKeyId}/${scope}, SignedHeaders=${signedHeaders}, Signature=${signature}`,
+    },
+    body,
+  });
+  if (!res.ok) return { ok: false, error: `SES [${res.status}]: ${await res.text()}` };
+  return { ok: true };
+}
+
+/* ---------------- Generic HTTP / webhook ---------------- */
+async function sendHttp(p: SendableProvider, payload: SendPayload, env: Env): Promise<SendResult> {
+  const url = str(p.config, "endpoint") ?? str(p.config, "url");
+  if (!url) return { ok: false, error: "Endpoint URL is missing in the provider config." };
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  const secret = secretOf(p, env);
+  if (secret) {
+    const headerName = str(p.config, "auth_header") ?? "Authorization";
+    const scheme = str(p.config, "auth_scheme");
+    headers[headerName] = scheme ? `${scheme} ${secret}` : secret;
+  }
+  const res = await fetch(url, {
+    method: (str(p.config, "method") ?? "POST").toUpperCase(),
+    headers,
+    body: JSON.stringify({
+      from: formatFrom(payload),
+      from_email: payload.fromEmail,
+      from_name: payload.fromName,
+      reply_to: payload.replyTo,
+      to: payload.to,
+      subject: payload.subject,
+      html: payload.html,
+      text: payload.text,
+    }),
+  });
+  if (!res.ok) return { ok: false, error: `Endpoint [${res.status}]: ${await res.text()}` };
+  return { ok: true };
+}
+
+/* ---------------- SMTP (raw socket, STARTTLS) ---------------- */
+async function sendSmtpProvider(
+  p: SendableProvider,
+  payload: SendPayload,
+  env: Env,
+): Promise<SendResult> {
+  const host = str(p.config, "host");
+  if (!host) return { ok: false, error: "SMTP host is missing in the provider config." };
+  const secret = resolveProviderSecret(p, env);
+  if (!secret.ok) return { ok: false, error: secret.error };
+  const rawPort = p.config?.port;
+  const port = Number(typeof rawPort === "string" ? rawPort.trim() : rawPort) || 587;
+  return sendSmtp(
+    { host, port, username: str(p.config, "username"), password: secret.value },
+    {
+      to: payload.to,
+      fromEmail: payload.fromEmail,
+      fromName: payload.fromName,
+      replyTo: payload.replyTo,
+      subject: payload.subject,
+      text: payload.text,
+      html: payload.html,
+    },
+  );
+}
+
+/** Dispatch one message through the provider's own transport. Never throws. */
+export async function sendViaProvider(
+  provider: SendableProvider,
+  payload: SendPayload,
+  options?: SendOptions,
+): Promise<SendResult> {
+  const env = envOf(options);
+  try {
+    switch (provider.kind) {
+      case "mailgun":
+        return await sendMailgun(provider, payload, env);
+      case "ses":
+        return await sendSes(provider, payload, env);
+      case "http":
+        return await sendHttp(provider, payload, env);
+      case "smtp":
+        return await sendSmtpProvider(provider, payload, env);
+      case "lovable":
+        return {
+          ok: false,
+          error:
+            "Lovable Emails sending is not wired up yet — set up the email domain first, or test another provider.",
+        };
+      default:
+        return { ok: false, error: `Unknown provider kind "${provider.kind}".` };
+    }
+  } catch (e) {
+    return { ok: false, error: e instanceof Error ? e.message : "Unknown send error" };
+  }
+}