@bygghammar/cms-platform 0.47.0 → 0.49.0

package/src/server/env.ts

@@ -0,0 +1,74 @@
+/**
+ * Supabase server environment resolution.
+ *
+ * Supports both the current key names and the named-key JSON bundles used by
+ * self-hosted stacks, plus the legacy service-role variable.
+ */
+export type SupabaseServerEnv = Partial<
+  Record<
+    | "SUPABASE_URL"
+    | "SUPABASE_PUBLISHABLE_KEYS"
+    | "SUPABASE_PUBLISHABLE_KEY"
+    | "SUPABASE_SECRET_KEYS"
+    | "SUPABASE_SECRET_KEY"
+    | "SUPABASE_SERVICE_ROLE_KEY",
+    string
+  >
+>;
+
+function defaultNamedKey(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+
+  try {
+    const parsed = JSON.parse(value) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return undefined;
+
+    const key = (parsed as Record<string, unknown>).default;
+    return typeof key === "string" && key.length > 0 ? key : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolve both current Supabase keys and the legacy self-host service-role key. */
+export function resolveSupabaseServerEnvironment(
+  env: SupabaseServerEnv = process.env as SupabaseServerEnv,
+): {
+  url: string | undefined;
+  publishableKey: string | undefined;
+  secretKey: string | undefined;
+} {
+  return {
+    url: env.SUPABASE_URL,
+    publishableKey: defaultNamedKey(env.SUPABASE_PUBLISHABLE_KEYS) ?? env.SUPABASE_PUBLISHABLE_KEY,
+    secretKey:
+      defaultNamedKey(env.SUPABASE_SECRET_KEYS) ??
+      env.SUPABASE_SECRET_KEY ??
+      env.SUPABASE_SERVICE_ROLE_KEY,
+  };
+}
+
+/**
+ * `fetch` shim for Supabase server clients.
+ *
+ * Opaque `sb_` keys are API keys, not bearer JWTs: PostgREST rejects them in an
+ * `Authorization` header, so send them only as `apikey`.
+ */
+export function createServerFetch(key: string): typeof fetch {
+  return (input, init) => {
+    const headers = new Headers(
+      typeof Request !== "undefined" && input instanceof Request ? input.headers : undefined,
+    );
+
+    if (init?.headers) {
+      new Headers(init.headers).forEach((value, name) => headers.set(name, value));
+    }
+
+    if (key.startsWith("sb_") && headers.get("Authorization") === `Bearer ${key}`) {
+      headers.delete("Authorization");
+    }
+
+    headers.set("apikey", key);
+    return fetch(input, { ...init, headers });
+  };
+}

package/src/server/http/backup.ts

@@ -0,0 +1,152 @@
+/**
+ * Backup/restore HTTP handler cores.
+ *
+ * The site route file only wires these to `createFileRoute`; authorisation and
+ * archive work are injected so the same HTTP contract holds on every site.
+ */
+export type BackupCaller = unknown;
+
+export type BackupDeps = {
+  /** Throws (or returns a Response) when the caller is not a superadmin. */
+  requireSuperadmin: (request: Request) => Promise<BackupCaller>;
+};
+
+function errorResponse(e: unknown, fallback: string, status: number): Response {
+  if (e instanceof Response) return e;
+  return new Response(e instanceof Error ? e.message : fallback, { status });
+}
+
+/** Dry run: inspect an uploaded archive without writing anything. */
+export async function backupAnalyzeResponse(
+  request: Request,
+  deps: BackupDeps & { analyzeArchive: (bytes: Uint8Array) => Promise<unknown> },
+): Promise<Response> {
+  try {
+    await deps.requireSuperadmin(request);
+    const bytes = new Uint8Array(await request.arrayBuffer());
+    if (!bytes.byteLength) return new Response("Empty upload", { status: 400 });
+    return Response.json(await deps.analyzeArchive(bytes));
+  } catch (e) {
+    return errorResponse(e, "Could not read archive", 400);
+  }
+}
+
+/** Row/media counts for the selected datasets, shown before an export runs. */
+export async function backupEstimateResponse(
+  request: Request,
+  deps: BackupDeps & {
+    countRows: (groups: string[], caller: BackupCaller) => Promise<unknown>;
+  },
+): Promise<Response> {
+  try {
+    const caller = await deps.requireSuperadmin(request);
+    const body = (await request.json()) as { groups?: string[] };
+    return Response.json(await deps.countRows(body.groups ?? [], caller));
+  } catch (e) {
+    return errorResponse(e, "Failed", 500);
+  }
+}
+
+/** Build and stream a backup archive. */
+export async function backupExportResponse(
+  request: Request,
+  deps: BackupDeps & {
+    buildArchive: (
+      caller: BackupCaller,
+      groups: string[],
+      site: string,
+      options: { deferMediaToBrowser: boolean },
+    ) => Promise<ArrayBufferLike | Uint8Array>;
+  },
+): Promise<Response> {
+  try {
+    const caller = await deps.requireSuperadmin(request);
+    const body = (await request.json()) as {
+      groups?: string[];
+      label?: string;
+      deferMediaToBrowser?: boolean;
+    };
+    const groups = body.groups ?? [];
+    if (!groups.length) return new Response("No datasets selected", { status: 400 });
+
+    const site = new URL(request.url).host;
+    const zip = await deps.buildArchive(caller, groups, site, {
+      deferMediaToBrowser: body.deferMediaToBrowser === true,
+    });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const name = `${(body.label ?? "backup").replace(/[^a-z0-9_-]/gi, "")}-${stamp}.zip`;
+
+    return new Response(new Uint8Array(zip as ArrayBufferLike), {
+      status: 200,
+      headers: {
+        "content-type": "application/zip",
+        "content-disposition": `attachment; filename="${name}"`,
+        "cache-control": "no-store",
+      },
+    });
+  } catch (e) {
+    return errorResponse(e, "Export failed", 500);
+  }
+}
+
+export type ImportOptions = {
+  groups: string[];
+  mode: "merge" | "replace";
+  includeMedia: boolean;
+  rewriteMediaBase: string | null;
+  keepInjectionsEnabled: boolean;
+};
+
+/**
+ * Apply an uploaded archive. Options travel as query parameters so the body
+ * stays the raw zip:  ?groups=content,forms&mode=merge&media=1
+ */
+export async function backupImportResponse(
+  request: Request,
+  deps: BackupDeps & {
+    importArchive: (
+      caller: BackupCaller,
+      bytes: Uint8Array,
+      options: ImportOptions,
+    ) => Promise<unknown>;
+    /** Fallback media base used when `?rewrite=1` has no explicit base. */
+    defaultMediaBase?: () => string;
+  },
+): Promise<Response> {
+  try {
+    const caller = await deps.requireSuperadmin(request);
+    const url = new URL(request.url);
+    const groups = (url.searchParams.get("groups") ?? "").split(",").filter(Boolean);
+    const mode = url.searchParams.get("mode") === "replace" ? "replace" : "merge";
+    const includeMedia = url.searchParams.get("media") === "1";
+    if (!groups.length) return new Response("No datasets selected", { status: 400 });
+
+    // Optional: make restored content point at this installation's media
+    // instead of the backend the archive was exported from.
+    const rewriteMediaBase =
+      url.searchParams.get("rewrite") === "1"
+        ? url.searchParams.get("mediaBase")?.trim() ||
+          (deps.defaultMediaBase?.() ??
+            process.env["MEDIA_PUBLIC_URL"]?.replace(/\/$/, "") ??
+            "/media")
+        : null;
+
+    // Restored tracking/code injections stay disabled unless asked for.
+    const keepInjectionsEnabled = url.searchParams.get("keepInjections") === "1";
+
+    const bytes = new Uint8Array(await request.arrayBuffer());
+    if (!bytes.byteLength) return new Response("Empty upload", { status: 400 });
+
+    return Response.json(
+      await deps.importArchive(caller, bytes, {
+        groups,
+        mode,
+        includeMedia,
+        rewriteMediaBase,
+        keepInjectionsEnabled,
+      }),
+    );
+  } catch (e) {
+    return errorResponse(e, "Import failed", 500);
+  }
+}

package/src/server/http/cms-content.ts

@@ -0,0 +1,26 @@
+/**
+ * Authenticated CMS write over plain HTTP.
+ *
+ * Delegates to the same `saveContentSection` server function the backoffice
+ * editor uses, so the bearer token, the staff role check and the row-level
+ * security rules all apply unchanged. No privileged database access happens
+ * here — the request runs as the signed-in user.
+ */
+export async function cmsContentResponse(
+  request: Request,
+  save: (body: unknown) => Promise<unknown>,
+): Promise<Response> {
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return Response.json({ ok: false, error: "Invalid JSON body." }, { status: 400 });
+  }
+  try {
+    return Response.json(await save(body));
+  } catch (err) {
+    const message = (err as Error).message || "Request failed";
+    const status = /unauthor|forbidden|sign in/i.test(message) ? 401 : 400;
+    return Response.json({ ok: false, error: message }, { status });
+  }
+}

package/src/server/http/fonts.ts

@@ -0,0 +1,38 @@
+/**
+ * Self-hosted font handler core.
+ *
+ * Filenames are content-hashed (`inter-latin-UcC73Fwr.woff2`), so responses
+ * carry the one-year immutable policy plus a matching `Expires`. WOFF2 is
+ * already compressed and never re-encoded, so no `Vary: Accept-Encoding`.
+ */
+import { cachePolicyFor, expiresHeader } from "../../http/cache-policy";
+
+export function fontResponse(options: {
+  request: Request;
+  method: "GET" | "HEAD";
+  splat: string | undefined;
+  fontBytes: (name: string) => ArrayBufferLike | Uint8Array | undefined;
+}): Response {
+  const name = decodeURIComponent(String(options.splat ?? ""));
+  const bytes = name.includes("/") ? undefined : options.fontBytes(name);
+  if (!bytes) return new Response("Not found", { status: 404 });
+
+  const url = new URL(options.request.url);
+  const policy = cachePolicyFor(url.pathname, url.search);
+  const etag = `"${bytes.byteLength.toString(16)}-${name}"`;
+  const headers: Record<string, string> = {
+    "Content-Type": "font/woff2",
+    "Content-Length": String(bytes.byteLength),
+    "Cache-Control": policy.cacheControl,
+    ETag: etag,
+  };
+  const expires = expiresHeader(policy);
+  if (expires) headers["Expires"] = expires;
+
+  if (options.request.headers.get("if-none-match") === etag) {
+    return new Response(null, { status: 304, headers });
+  }
+  const body =
+    options.method === "HEAD" ? null : new Uint8Array(bytes as ArrayBufferLike).slice().buffer;
+  return new Response(body as ArrayBuffer | null, { status: 200, headers });
+}

package/src/server/http/health.ts

@@ -0,0 +1,38 @@
+/**
+ * Liveness/readiness handler core.
+ *
+ * A container that starts with a broken/missing backend configuration must fail
+ * its health gate so the reverse proxy does not send traffic to it.
+ */
+export type HealthPayload = {
+  status: "ok" | "error";
+  backendConfigured: boolean;
+  version: string;
+};
+
+export async function healthResponse(options: {
+  /** Cheap backend reachability probe; throwing means "not configured". */
+  probe: () => Promise<unknown>;
+  /** Deployed image tag / version string. */
+  version?: string;
+}): Promise<Response> {
+  const payload: HealthPayload = {
+    status: "ok",
+    backendConfigured: false,
+    version:
+      options.version ||
+      process.env["APP_VERSION"] ||
+      process.env["VITE_PUBLIC_APP_VERSION"] ||
+      "unknown",
+  };
+
+  try {
+    await options.probe();
+    payload.backendConfigured = true;
+  } catch {
+    payload.backendConfigured = false;
+    payload.status = "error";
+  }
+
+  return Response.json(payload, { status: payload.status === "ok" ? 200 : 503 });
+}

package/src/server/http/robots.ts

@@ -0,0 +1,53 @@
+/**
+ * robots.txt handler core.
+ *
+ * Generated at request time so the `Sitemap:` line always points at the site's
+ * own default domain — a static file in `public/` goes stale the moment the
+ * domain changes.
+ */
+export type RobotsOptions = {
+  /** The incoming request URL, used as the host fallback. */
+  requestUrl: string;
+  /** Resolve the site's preferred (default) host, e.g. from the domains table. */
+  resolvePreferredHost?: () => Promise<string | undefined>;
+  /** Paths that generic crawlers must not index. */
+  disallow?: string[];
+  /** Crawlers explicitly allowed everything. */
+  allowedAgents?: string[];
+  /** `Cache-Control` for the response. */
+  cacheControl?: string;
+};
+
+export const DEFAULT_ALLOWED_AGENTS = [
+  "Googlebot",
+  "Bingbot",
+  "Twitterbot",
+  "facebookexternalhit",
+];
+
+export async function robotsResponse(options: RobotsOptions): Promise<Response> {
+  let host = new URL(options.requestUrl).host;
+  if (options.resolvePreferredHost) {
+    try {
+      const preferred = await options.resolvePreferredHost();
+      if (preferred) host = preferred.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    } catch {
+      // Fall back to the request host if the domain source is unavailable.
+    }
+  }
+
+  const lines: string[] = [];
+  for (const agent of options.allowedAgents ?? DEFAULT_ALLOWED_AGENTS) {
+    lines.push(`User-agent: ${agent}`, "Allow: /", "");
+  }
+  lines.push("User-agent: *", "Allow: /");
+  for (const path of options.disallow ?? []) lines.push(`Disallow: ${path}`);
+  lines.push("", `Sitemap: https://${host}/sitemap.xml`, "");
+
+  return new Response(lines.join("\n"), {
+    headers: {
+      "Content-Type": "text/plain; charset=utf-8",
+      "Cache-Control": options.cacheControl ?? "public, max-age=3600",
+    },
+  });
+}

package/src/server/http/sitemap.ts

@@ -0,0 +1,63 @@
+/**
+ * sitemap.xml handler cores.
+ *
+ * `sitemapIndexXml` builds the index (one sitemap per configured domain);
+ * `sitemapUrlsetXml` builds a per-locale urlset with hreflang alternates.
+ */
+export type SitemapIndexEntry = { url: string };
+
+export type SitemapUrlEntry = {
+  pageKey: string;
+  url: string;
+  alternates: Array<{ locale: string; url: string }>;
+  changefreq?: string;
+  priority?: string;
+};
+
+const XML_HEADERS = {
+  "Content-Type": "application/xml",
+  "Cache-Control": "public, max-age=3600",
+} as const;
+
+export function sitemapIndexXml(entries: SitemapIndexEntry[]): string {
+  const sitemaps = entries.map((e) => `  <sitemap>\n    <loc>${e.url}</loc>\n  </sitemap>`);
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">`,
+    ...sitemaps,
+    `</sitemapindex>`,
+  ].join("\n");
+}
+
+export function sitemapIndexResponse(entries: SitemapIndexEntry[]): Response {
+  return new Response(sitemapIndexXml(entries), { headers: { ...XML_HEADERS } });
+}
+
+export function sitemapUrlsetXml(entries: SitemapUrlEntry[], homeKey = "home"): string {
+  const urls = entries.map((e) => {
+    const alts = e.alternates
+      .map((a) => `    <xhtml:link rel="alternate" hreflang="${a.locale}" href="${a.url}" />`)
+      .join("\n");
+    return [
+      `  <url>`,
+      `    <loc>${e.url}</loc>`,
+      alts,
+      `    <changefreq>${e.changefreq ?? "weekly"}</changefreq>`,
+      `    <priority>${e.priority ?? (e.pageKey === homeKey ? "1.0" : "0.7")}</priority>`,
+      `  </url>`,
+    ]
+      .filter(Boolean)
+      .join("\n");
+  });
+
+  return [
+    `<?xml version="1.0" encoding="UTF-8"?>`,
+    `<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">`,
+    ...urls,
+    `</urlset>`,
+  ].join("\n");
+}
+
+export function sitemapUrlsetResponse(entries: SitemapUrlEntry[], homeKey = "home"): Response {
+  return new Response(sitemapUrlsetXml(entries, homeKey), { headers: { ...XML_HEADERS } });
+}

package/src/site/PageRenderer.tsx

@@ -0,0 +1,151 @@
+/**
+ * Public-site block renderers (site-agnostic).
+ *
+ * A block instance tree plus a block registry is all that is needed to render
+ * a published page or an unsaved draft. The registry is passed in, so a site
+ * only supplies its own block definitions.
+ */
+import { queryOptions, useSuspenseQuery } from "@tanstack/react-query";
+
+import type { BlockDef } from "../blocks/registry";
+import type { BlockInstance, BlockProps } from "../blocks/types";
+
+export type BlockRegistry = Record<string, BlockDef>;
+
+export type RenderedPage = {
+  blocks: BlockInstance[];
+  globals: Record<string, BlockInstance[]>;
+};
+
+function RenderBlock({
+  block,
+  globals,
+  registry,
+  edit,
+  selectedId,
+}: {
+  block: BlockInstance;
+  globals: Record<string, BlockInstance[]>;
+  registry: BlockRegistry;
+  edit?: boolean;
+  selectedId?: string | null;
+}) {
+  if (block.visible === false) return null;
+
+  if (block.type === "globalRef") {
+    const sectionKey = String((block.props as BlockProps | undefined)?.sectionKey ?? "");
+    const inner = globals[sectionKey] ?? [];
+    const children = inner.map((b) => (
+      <RenderBlock
+        key={b.id}
+        block={b}
+        globals={globals}
+        registry={registry}
+        edit={edit}
+        selectedId={selectedId}
+      />
+    ));
+    if (!edit) return <>{children}</>;
+    return (
+      <div
+        data-block-id={block.id}
+        data-block-type="globalRef"
+        data-selected={selectedId === block.id ? "true" : undefined}
+        className="lovable-block"
+      >
+        {children}
+      </div>
+    );
+  }
+
+  const def = registry[block.type];
+  if (!def) return null;
+  const Cmp = def.component;
+  const rendered = <Cmp props={(block.props ?? {}) as BlockProps} />;
+
+  if (!edit) return rendered;
+
+  return (
+    <div
+      data-block-id={block.id}
+      data-block-type={block.type}
+      data-selected={selectedId === block.id ? "true" : undefined}
+      className="lovable-block"
+    >
+      {rendered}
+    </div>
+  );
+}
+
+/** Render an in-memory block tree — used by the builder preview and drafts. */
+export function DraftPageRendererView({
+  blocks,
+  globals,
+  registry,
+  edit,
+  selectedId,
+}: {
+  blocks: BlockInstance[];
+  globals: Record<string, BlockInstance[]>;
+  registry: BlockRegistry;
+  edit?: boolean;
+  selectedId?: string | null;
+}) {
+  return (
+    <>
+      {blocks.map((b) => (
+        <RenderBlock
+          key={b.id}
+          block={b}
+          globals={globals}
+          registry={registry}
+          edit={edit}
+          selectedId={selectedId}
+        />
+      ))}
+    </>
+  );
+}
+
+/** Query options for one published page, keyed by page key. */
+export function createPageQueryOptions(
+  fetchPublishedPage: (key: string) => Promise<RenderedPage | null>,
+) {
+  return (key: string) =>
+    queryOptions({
+      queryKey: ["cms", "page", key],
+      queryFn: () => fetchPublishedPage(key),
+      staleTime: 30_000,
+    });
+}
+
+/**
+ * Build the published-page renderer for a site.
+ * `fetchPublishedPage` is the site's `getPublishedPage` server function.
+ */
+export function createPageRenderer(
+  registry: BlockRegistry,
+  fetchPublishedPage: (key: string) => Promise<RenderedPage | null>,
+) {
+  const pageQueryOptions = createPageQueryOptions(fetchPublishedPage);
+
+  function PageRenderer({ pageKey }: { pageKey: string }) {
+    const { data } = useSuspenseQuery(pageQueryOptions(pageKey));
+    const page = data as RenderedPage | null;
+    if (!page) return null;
+    return (
+      <DraftPageRendererView blocks={page.blocks} globals={page.globals} registry={registry} />
+    );
+  }
+
+  function DraftPageRenderer(props: {
+    blocks: BlockInstance[];
+    globals: Record<string, BlockInstance[]>;
+    edit?: boolean;
+    selectedId?: string | null;
+  }) {
+    return <DraftPageRendererView {...props} registry={registry} />;
+  }
+
+  return { pageQueryOptions, PageRenderer, DraftPageRenderer };
+}