@bygghammar/cms-platform 0.49.0 → 0.50.0

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.50.0
+
+- New `runtime/server-entry`: `createServerEntry({ injections })` is the shared production fetch handler — framework entry, h3-swallowed-500 normalisation, backoffice code injection and edge caching/compression headers. A site's `src/server.ts` drops to one call.
+- New `server/media-usage-host`: `createMediaUsageTools({ storage, admin, backofficePrefix, pagePublicPath, userAgent })` returns the staff-guarded `scanMediaUsage`, `importRemoteUrlToMedia` and `rewriteMediaReferences`, so only the page-key → public-path map stays site-local.
+
+## 0.49.1
+
+- `server/http/backup`: the export response streams the archive as an `ArrayBuffer`, keeping the handler typed under `lib.dom` fetch signatures.
+
 ## 0.49.0
 
 - Public-site runtime and backend plumbing are package-owned. New `site/routes`: `createSiteRoutes(pages)` derives `resolveRoute`, `pageHeadMeta`, canonical/hreflang assembly and `sitemapIndexEntries`/`sitemapUrls` from a site's page registry, so every site gets identical SEO behaviour.

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.49.0",
+  "version": "0.50.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": [
-    "./src/runtime/error-capture.ts"
+    "./src/runtime/error-capture.ts",
+    "./src/runtime/server-entry.ts"
   ],
   "license": "UNLICENSED",
   "publishConfig": {
@@ -193,7 +194,9 @@
     "./server/http/cms-content": "./src/server/http/cms-content.ts",
     "./runtime/error-capture": "./src/runtime/error-capture.ts",
     "./runtime/error-page": "./src/runtime/error-page.ts",
-    "./runtime/error-reporting": "./src/runtime/error-reporting.ts"
+    "./runtime/error-reporting": "./src/runtime/error-reporting.ts",
+    "./server/media-usage-host": "./src/server/media-usage-host.ts",
+    "./runtime/server-entry": "./src/runtime/server-entry.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/runtime/server-entry.ts

@@ -0,0 +1,139 @@
+/**
+ * The shared production server entry.
+ *
+ * Static files (hashed /assets/*, self-hosted /fonts/*, favicons) are served by
+ * the framework's public-asset handler, which runs before any route
+ * middleware, so wrapping the entry is the only place where those responses can
+ * still receive the deployment's caching policy.
+ *
+ * Compression stays opt-in (`EDGE_COMPRESSION`) so the app never competes with
+ * Traefik/Cloudflare.
+ */
+import "./error-capture";
+
+import { consumeLastCapturedError } from "./error-capture";
+import { renderErrorPage } from "./error-page";
+import { applyEdgeHeaders } from "../http/response-headers";
+
+export type SiteCodeInjections = {
+  /** Whether backoffice-managed code may be injected on this path. */
+  isInjectablePath: (pathname: string) => boolean;
+  /** Head / body-start / body-end snippets for the requesting host. */
+  resolve: (host: string) => Promise<{
+    head?: string;
+    bodyStart?: string;
+    bodyEnd?: string;
+  }>;
+  /** Applies a resolved bundle to the rendered HTML. */
+  apply: (
+    html: string,
+    bundle: { head?: string; bodyStart?: string; bodyEnd?: string },
+  ) => string;
+};
+
+export type ServerEntryOptions = {
+  /**
+   * Loads the site's injection helpers lazily, so the tracking module never
+   * enters the SSR module graph for sites that do not use it.
+   */
+  injections?: () => Promise<SiteCodeInjections>;
+};
+
+type ServerEntry = {
+  fetch: (request: Request, env: unknown, ctx: unknown) => Promise<Response> | Response;
+};
+
+function compressionEnabled(): boolean {
+  const flag = process.env["EDGE_COMPRESSION"];
+  return flag === "1" || flag === "on";
+}
+
+let serverEntryPromise: Promise<ServerEntry> | undefined;
+
+async function getFrameworkEntry(): Promise<ServerEntry> {
+  if (!serverEntryPromise) {
+    serverEntryPromise = import("@tanstack/react-start/server-entry").then(
+      (m) => ((m as { default?: ServerEntry }).default ?? m) as ServerEntry,
+    );
+  }
+  return serverEntryPromise;
+}
+
+function isH3SwallowedErrorBody(body: string): boolean {
+  try {
+    const payload = JSON.parse(body) as { unhandled?: unknown; message?: unknown };
+    return payload.unhandled === true && payload.message === "HTTPError";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * h3 swallows in-handler throws into a normal 500 Response with body
+ * `{"unhandled":true,"message":"HTTPError"}` — try/catch alone never fires for
+ * those, so the swallowed body is detected and replaced with the error page.
+ */
+async function normalizeCatastrophicSsrResponse(response: Response): Promise<Response> {
+  if (response.status < 500) return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("application/json")) return response;
+
+  const body = await response.clone().text();
+  if (!isH3SwallowedErrorBody(body)) return response;
+
+  console.error(consumeLastCapturedError() ?? new Error(`h3 swallowed SSR error: ${body}`));
+  return new Response(renderErrorPage(), {
+    status: 500,
+    headers: { "content-type": "text/html; charset=utf-8" },
+  });
+}
+
+async function injectSiteCode(
+  request: Request,
+  response: Response,
+  load: () => Promise<SiteCodeInjections>,
+): Promise<Response> {
+  if (response.status >= 400) return response;
+  const contentType = response.headers.get("content-type") ?? "";
+  if (!contentType.includes("text/html")) return response;
+
+  try {
+    const injections = await load();
+    const url = new URL(request.url);
+    if (!injections.isInjectablePath(url.pathname)) return response;
+
+    const bundle = await injections.resolve(url.host);
+    if (!bundle.head && !bundle.bodyStart && !bundle.bodyEnd) return response;
+
+    const html = injections.apply(await response.text(), bundle);
+    const headers = new Headers(response.headers);
+    headers.delete("content-length");
+    return new Response(html, { status: response.status, headers });
+  } catch (error) {
+    console.error("site code injection failed", error);
+    return response;
+  }
+}
+
+/** Builds the default-exported fetch handler for a site's `src/server.ts`. */
+export function createServerEntry(options: ServerEntryOptions = {}) {
+  return {
+    async fetch(request: Request, env: unknown, ctx: unknown): Promise<Response> {
+      try {
+        const handler = await getFrameworkEntry();
+        const response = await handler.fetch(request, env, ctx);
+        const normalized = await normalizeCatastrophicSsrResponse(response);
+        const injected = options.injections
+          ? await injectSiteCode(request, normalized, options.injections)
+          : normalized;
+        return await applyEdgeHeaders(request, injected, { compress: compressionEnabled() });
+      } catch (error) {
+        console.error(error);
+        return new Response(renderErrorPage(), {
+          status: 500,
+          headers: { "content-type": "text/html; charset=utf-8" },
+        });
+      }
+    },
+  };
+}

package/src/server/http/backup.ts

@@ -76,7 +76,8 @@ export async function backupExportResponse(
     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), {
+    const zipBytes = new Uint8Array(zip as ArrayBufferLike);
+    return new Response(zipBytes.buffer as ArrayBuffer, {
       status: 200,
       headers: {
         "content-type": "application/zip",

package/src/server/media-usage-host.ts

@@ -0,0 +1,76 @@
+/**
+ * Host wiring for the media usage tools.
+ *
+ * The scanning, import and rewrite logic lives in `media-usage-core`. This
+ * factory turns it into the three staff-guarded functions every site exposes,
+ * so a site only declares the facts it owns: how to build its storage provider,
+ * its backoffice prefix, its page-key → public-path map and a User-Agent.
+ */
+import { assertStaff } from "./guards";
+import {
+  importRemoteUrlCore,
+  rewriteMediaReferencesCore,
+  scanMediaUsageCore,
+  type MediaImportHost,
+  type MediaUsageHost,
+  type UsageStorage,
+} from "./media-usage-core";
+import type { MediaImportResult, MediaUsageReport } from "../media/usage-types";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type MediaUsageToolsOptions = {
+  /** Builds the site's storage provider from the request-scoped client. */
+  storage: (db: any) => UsageStorage;
+  /** Privileged client factory, used for reference rewriting on import. */
+  admin: () => Promise<any>;
+  /** Backoffice route prefix, e.g. `/kontoret`. */
+  backofficePrefix?: string;
+  /** Public URL path for a CMS page key, when the site has one. */
+  pagePublicPath?: (pageKey: string) => string | undefined;
+  /** User-Agent sent when fetching remote media. */
+  userAgent?: string;
+};
+
+export type MediaUsageTools = {
+  scanMediaUsage: (context: any) => Promise<MediaUsageReport>;
+  importRemoteUrlToMedia: (
+    data: { url: string; filename?: string },
+    context: any,
+  ) => Promise<MediaImportResult>;
+  rewriteMediaReferences: (db: any, oldUrls: string[], newUrl: string) => Promise<number>;
+};
+
+export function createMediaUsageTools(options: MediaUsageToolsOptions): MediaUsageTools {
+  const hostFor = (context: any): MediaUsageHost => {
+    const db = context.supabase;
+    return {
+      db,
+      storage: options.storage(db),
+      backofficePrefix: options.backofficePrefix,
+      pagePublicPath: options.pagePublicPath,
+    };
+  };
+
+  return {
+    async scanMediaUsage(context) {
+      await assertStaff(context);
+      return scanMediaUsageCore(hostFor(context));
+    },
+
+    async importRemoteUrlToMedia(data, context) {
+      await assertStaff(context);
+      const admin = await options.admin();
+      const host: MediaImportHost = {
+        ...hostFor(context),
+        admin,
+        userAgent: options.userAgent,
+      };
+      return importRemoteUrlCore(data, host);
+    },
+
+    rewriteMediaReferences(db, oldUrls, newUrl) {
+      return rewriteMediaReferencesCore(db, oldUrls, newUrl);
+    },
+  };
+}