@bygghammar/cms-platform 0.59.0 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.60.0
+
+- New backoffice screen `backoffice/SitemapView` plus the `SitemapRoute` route
+  and `paths.sitemap`: fetches the deployment's own `/sitemap.xml`,
+  per-locale `/sitemap/<locale>.xml` and `/robots.txt` and shows status,
+  entry counts and the served body, next to the read-only indexing status.
+- New `server/published-cache`: a short-lived in-process cache for published
+  page reads, wired into `getPublishedPageCore` and dropped by every page and
+  global-section write in `server/pages-core`, so editor previews load faster
+  without ever serving replaced content.
+
+## 0.59.1
+
+- `site/routes/public-page`: path resolution uses the platform `notfound` kind
+  and the fallback screens are typed as function components.
+
 ## 0.59.0
 
 - Added `site/routes/public-page`, `site/routes/preview-page` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.59.0",
+  "version": "0.60.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": [
@@ -120,6 +120,7 @@
     "./config/site-config": "./src/config/site-config.ts",
     "./server/site-settings-core": "./src/server/site-settings-core.ts",
     "./backoffice/SiteSettingsView": "./src/backoffice/SiteSettingsView.tsx",
+    "./backoffice/SitemapView": "./src/backoffice/SitemapView.tsx",
     "./backoffice/UsersView": "./src/backoffice/UsersView.tsx",
     "./backoffice/RolesView": "./src/backoffice/RolesView.tsx",
     "./backoffice/AuditView": "./src/backoffice/AuditView.tsx",
@@ -149,6 +150,7 @@
     "./server/media-library-core": "./src/server/media-library-core.ts",
     "./server/admin-core": "./src/server/admin-core.ts",
     "./server/pages-core": "./src/server/pages-core.ts",
+    "./server/published-cache": "./src/server/published-cache.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",

package/src/backoffice/SitemapView.tsx

@@ -0,0 +1,111 @@
+import type { ReactNode } from "react";
+
+import { IndexingStatusCard } from "./IndexingStatusCard";
+import type { IndexingPolicy } from "../site/indexing";
+
+/** One fetched file: what was requested and what the site actually answered. */
+export type SitemapCheck = {
+  label: string;
+  path: string;
+  status: number | null;
+  contentType: string | null;
+  /** Entry count for XML, line count for robots.txt. Null when unknown. */
+  count: number | null;
+  body: string;
+  error?: string;
+};
+
+/**
+ * Search-engine files screen.
+ *
+ * `robots.txt` and the sitemaps are generated at request time by the platform's
+ * own route handlers, so the only meaningful question a backoffice can answer is
+ * whether they are actually being served from this deployment, with this
+ * deployment's origin and locale rules. That is a verification, not a setting —
+ * so this screen fetches the live files and shows exactly what a crawler gets.
+ */
+export function SitemapView({
+  origin,
+  locales,
+  indexing,
+  checks,
+  loading,
+  onRefresh,
+}: {
+  origin: string;
+  locales: readonly string[];
+  indexing?: IndexingPolicy;
+  checks: SitemapCheck[];
+  loading?: boolean;
+  onRefresh: () => void;
+}): ReactNode {
+  return (
+    <div className="p-8 md:p-12 w-full space-y-8">
+      <div className="flex flex-wrap items-end justify-between gap-4">
+        <div>
+          <h2 className="font-serif text-xl text-ink">Sitemap &amp; robots.txt</h2>
+          <p className="mt-2 max-w-2xl text-sm text-ink/60">
+            Generated for every request from this deployment&apos;s origin and locales — never a
+            static file that can go stale. Public origin <code>{origin}</code>, locales{" "}
+            <code>{locales.join(", ")}</code>.
+          </p>
+        </div>
+        <button
+          type="button"
+          onClick={onRefresh}
+          className="border border-ink/20 px-4 py-2 text-sm text-ink hover:border-sea"
+        >
+          {loading ? "Checking…" : "Check again"}
+        </button>
+      </div>
+
+      <IndexingStatusCard indexing={indexing} />
+
+      <div className="space-y-6">
+        {checks.map((c) => {
+          const ok = c.status === 200 && !c.error;
+          return (
+            <div key={c.path} className="border border-ink/10 bg-white">
+              <div className="flex flex-wrap items-center justify-between gap-3 border-b border-ink/10 px-4 py-3">
+                <div>
+                  <div className="text-sm text-ink">{c.label}</div>
+                  <a
+                    href={c.path}
+                    target="_blank"
+                    rel="noreferrer"
+                    className="text-xs text-sea underline"
+                  >
+                    {c.path}
+                  </a>
+                </div>
+                <div className="flex items-center gap-3 text-xs">
+                  {c.count !== null && (
+                    <span className="text-ink/50">
+                      {c.count} {c.path.endsWith(".xml") ? "entries" : "lines"}
+                    </span>
+                  )}
+                  <span className="text-ink/40">{c.contentType ?? "—"}</span>
+                  <span
+                    className={
+                      ok
+                        ? "bg-sea/10 px-2 py-1 uppercase tracking-wider text-sea"
+                        : "bg-red-50 px-2 py-1 uppercase tracking-wider text-red-600"
+                    }
+                  >
+                    {c.error ? "Failed" : `HTTP ${c.status ?? "?"}`}
+                  </span>
+                </div>
+              </div>
+              <pre className="max-h-64 overflow-auto px-4 py-3 text-[11px] leading-relaxed text-ink/70">
+                {c.error ?? c.body.slice(0, 4000) ?? ""}
+              </pre>
+            </div>
+          );
+        })}
+        {!checks.length && !loading && (
+          <p className="text-sm text-ink/50">Nothing checked yet.</p>
+        )}
+      </div>
+    </div>
+  );
+}

package/src/backoffice/routes/host.ts

@@ -282,6 +282,7 @@ export function backofficePaths(host: BackofficeHost = backofficeHost()) {
     contact: `${base}/admin/contact`,
     tracking: `${base}/admin/tracking`,
     redirects: `${base}/admin/redirects`,
+    sitemap: `${base}/admin/sitemap`,
     navigation: `${base}/admin/navigation`,
     version: `${base}/admin/version`,
     backup: `${base}/admin/backup`,

package/src/backoffice/routes/index.tsx

@@ -21,6 +21,7 @@ import {
   Shield,
   Signpost,
   SlidersHorizontal,
+  Globe,
   Users,
 } from "lucide-react";
 import { useQuery, useQueryClient } from "@tanstack/react-query";
@@ -39,6 +40,7 @@ import { FormSettingsView } from "../FormSettingsView";
 import { LogsView } from "../LogsView";
 import { RedirectsView } from "../RedirectsView";
 import { RolesView } from "../RolesView";
+import { SitemapView, type SitemapCheck } from "../SitemapView";
 import { SiteSettingsView } from "../SiteSettingsView";
 import { TrackingView } from "../TrackingView";
 import { UsersView } from "../UsersView";
@@ -372,6 +374,12 @@ export function AdminOverviewRoute() {
       body: "Old URLs pointing to new ones, created automatically on slug changes.",
       icon: Signpost,
     },
+    {
+      to: paths.sitemap,
+      title: "Sitemap & robots.txt",
+      body: "Verify the generated sitemap index, per-locale sitemaps and robots.txt served by this deployment.",
+      icon: Globe,
+    },
     {
       to: paths.navigation,
       title: "Navigation & footer",
@@ -415,6 +423,74 @@ export function AdminOverviewRoute() {
   );
 }
 
+/**
+ * Sitemap and robots.txt verification screen.
+ *
+ * Both files are generated by the platform's own route handlers, so the screen
+ * fetches them from this deployment and shows what a crawler actually receives.
+ * Nothing here is editable: origin and locales come from configuration, and the
+ * indexing decision is an environment fact.
+ */
+export function SitemapRoute() {
+  const host = backofficeHost();
+  const fetchSettings = useServerFn(host.fns.getSiteSettings);
+  const settingsQ = useQuery({
+    queryKey: ["admin", "site-settings"],
+    queryFn: () => fetchSettings(),
+  });
+
+  const paths = [
+    { label: "Sitemap index", path: "/sitemap.xml" },
+    ...host.locales.map((l) => ({ label: `Sitemap — ${l}`, path: `/sitemap/${l}.xml` })),
+    { label: "robots.txt", path: "/robots.txt" },
+  ];
+
+  const checksQ = useQuery({
+    queryKey: ["admin", "sitemap-checks", host.locales.join(",")],
+    queryFn: async (): Promise<SitemapCheck[]> =>
+      Promise.all(
+        paths.map(async ({ label, path }) => {
+          try {
+            const res = await fetch(path, { headers: { Accept: "*/*" }, cache: "no-store" });
+            const body = await res.text();
+            const count = path.endsWith(".xml")
+              ? (body.match(/<(?:url|sitemap)>/g) ?? []).length
+              : body.split("\n").filter((l) => l.trim()).length;
+            return {
+              label,
+              path,
+              status: res.status,
+              contentType: res.headers.get("content-type"),
+              count,
+              body,
+            };
+          } catch (err) {
+            return {
+              label,
+              path,
+              status: null,
+              contentType: null,
+              count: null,
+              body: "",
+              error: err instanceof Error ? err.message : "Request failed",
+            };
+          }
+        }),
+      ),
+  });
+
+  return (
+    <SitemapView
+      origin={(settingsQ.data as { config?: { origin?: string } } | undefined)?.config?.origin ?? host.siteConfig.origin}
+      locales={host.locales}
+      indexing={(settingsQ.data as { indexing?: never } | undefined)?.indexing}
+      checks={checksQ.data ?? []}
+      loading={checksQ.isFetching}
+      onRefresh={() => void checksQ.refetch()}
+    />
+  );
+}
+
 /** Email sending settings plus provider credentials. */
 export function EmailSettingsRoute() {
   const host = backofficeHost();

package/src/config/package-owned-modules.ts

@@ -18,6 +18,11 @@ export type OwnedModule = {
 };
 
 export const PACKAGE_OWNED_MODULES: OwnedModule[] = [
+  {
+    site: "src/routes/kontoret.admin.sitemap.tsx",
+    packageModule: "@bygghammar/cms-platform/backoffice/routes",
+    optional: true,
+  },
   { site: "src/lib/i18n/routes.ts", packageModule: "@bygghammar/cms-platform/site/routes" },
   {
     site: "src/lib/i18n/page-context.ts",

package/src/server/pages-core.ts

@@ -12,6 +12,10 @@ import { diffBlocks, summarizeChanges } from "../cms/version-diff";
 import type { VersionChange } from "../cms/version-diff";
 import { actorEmail, assertStaff, assertSuperadmin } from "./guards";
 import type { PlatformAuthContext } from "./guards";
+import {
+  invalidatePublishedCache,
+  withPublishedCache,
+} from "./published-cache";
 import { resolveGlobalsDeep } from "./resolve-globals";
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -46,6 +50,12 @@ export async function getPublishedPageCore(
   client: any,
   key: string,
 ): Promise<ResolvedPage | null> {
+  // Cached per key and dropped by every page/global write below, so a preview
+  // reload costs one database round trip instead of several.
+  return withPublishedCache("page", key, () => readPublishedPage(client, key));
+}
+
+async function readPublishedPage(client: any, key: string): Promise<ResolvedPage | null> {
   const { data: page } = await client
     .from("pages")
     .select("id,key,name,current_version_id")
@@ -128,6 +138,7 @@ export async function savePageVersionCore(
   input: { pageId: string; blocks: BlockInstance[]; publish?: boolean; note?: string },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { data: last } = await context.supabase
     .from("page_versions")
     .select("version_no")
@@ -243,6 +254,8 @@ export async function restorePageVersionCore(deps: PagesDeps, versionId: string)
 
 export async function createPageCore({ context }: PagesDeps, input: { key: string; name: string }) {
   await assertStaff(context);
+  invalidatePublishedCache();
+  invalidatePublishedCache();
   const { data: page, error } = await context.supabase
     .from("pages")
     .insert({ key: input.key, name: input.name, is_system: false, status: "draft" })
@@ -265,6 +278,7 @@ export async function renamePageCore(
   input: { pageId: string; name: string },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { error } = await context.supabase
     .from("pages")
     .update({ name: input.name })
@@ -283,6 +297,7 @@ export async function renamePageCore(
 /** Soft delete: moves the page to the trash bin. Never destroys data. */
 export async function deletePageCore({ context }: PagesDeps, pageId: string) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const email = actorEmail(context);
   const { data: page } = await context.supabase
     .from("pages")
@@ -342,6 +357,7 @@ export async function listDeletedPagesCore({
 
 export async function restorePageCore({ context }: PagesDeps, pageId: string) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { error } = await context.supabase
     .from("pages")
     .update({ deleted_at: null, deleted_by: null, deleted_by_email: null })
@@ -361,6 +377,7 @@ export async function restorePageCore({ context }: PagesDeps, pageId: string) {
 /** Permanent delete from the trash bin — superadmin only. */
 export async function purgePageCore({ context }: PagesDeps, pageId: string) {
   await assertStaff(context);
+  invalidatePublishedCache();
   await assertSuperadmin(context);
   const { data: page } = await context.supabase
     .from("pages")
@@ -455,6 +472,7 @@ export async function createGlobalSectionCore(
   input: { key: string; name: string; blocks?: BlockInstance[]; kind?: "block" | "section" },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const kind = input.kind ?? "section";
   if (kind === "block") assertSingleBlock(input.blocks ?? []);
   const { data: gs, error } = await context.supabase
@@ -487,6 +505,7 @@ export async function setGlobalSectionKindCore(
   input: { sectionId: string; kind: "block" | "section" },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   if (input.kind === "block") {
     const { data: gs } = await context.supabase
       .from("global_sections")
@@ -515,6 +534,7 @@ export async function saveGlobalSectionVersionCore(
   input: { sectionId: string; blocks: BlockInstance[]; note?: string },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { data: meta } = await context.supabase
     .from("global_sections")
     .select("kind")
@@ -553,6 +573,7 @@ export async function renameGlobalSectionCore(
   input: { sectionId: string; name: string },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { error } = await context.supabase
     .from("global_sections")
     .update({ name: input.name })
@@ -563,6 +584,7 @@ export async function renameGlobalSectionCore(
 
 export async function deleteGlobalSectionCore({ context }: PagesDeps, sectionId: string) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { error } = await context.supabase
     .from("global_sections")
     .delete()
@@ -596,6 +618,7 @@ export async function schedulePageVersionCore(
   input: { versionId: string; publishAt: string; unpublishAt?: string | null; note?: string },
 ) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { data: v, error: vErr } = await context.supabase
     .from("page_versions")
     .select("page_id")
@@ -649,6 +672,7 @@ export async function listPagePublicationsCore(
 
 export async function cancelPagePublicationCore({ context }: PagesDeps, publicationId: string) {
   await assertStaff(context);
+  invalidatePublishedCache();
   const { error } = await context.supabase
     .from("page_publications")
     .update({ is_active: false })

package/src/server/published-cache.ts

@@ -0,0 +1,121 @@
+/**
+ * Server-side cache for published page content.
+ *
+ * The page builder's preview route re-reads the published page and every global
+ * section it references on each load, which is several round trips to the
+ * database for content that only changes when an editor saves. This module
+ * keeps those reads in the server process for a short time and — the part that
+ * matters — drops them the moment any page or global section is written, so a
+ * preview never shows content that has already been replaced.
+ *
+ * Deliberately a plain in-process map: it must be free of infrastructure so it
+ * works identically in the Worker runtime, the self-hosted Node server and
+ * tests. A cold process simply has an empty cache.
+ */
+
+export type PublishedCacheScope = "page" | "global" | "custom";
+
+type Entry = { value: unknown; expiresAt: number };
+
+const store = new Map<string, Entry>();
+
+/** How long an entry may be served before it is re-read. */
+let ttlMs = 20_000;
+
+/** Cheap counters so the backoffice can show whether the cache is working. */
+let hits = 0;
+let misses = 0;
+let invalidations = 0;
+
+const cacheKey = (scope: PublishedCacheScope, key: string) => `${scope}:${key}`;
+
+/** Sets the entry lifetime. `0` disables caching entirely. */
+export function setPublishedCacheTtl(ms: number): void {
+  ttlMs = Math.max(0, ms);
+  if (ttlMs === 0) store.clear();
+}
+
+/** Current entry lifetime in milliseconds. */
+export function publishedCacheTtl(): number {
+  return ttlMs;
+}
+
+/** Reads a live entry, or `undefined` when absent or expired. */
+export function publishedCacheGet<T>(scope: PublishedCacheScope, key: string): T | undefined {
+  if (ttlMs === 0) return undefined;
+  const entry = store.get(cacheKey(scope, key));
+  if (!entry) return undefined;
+  if (entry.expiresAt <= Date.now()) {
+    store.delete(cacheKey(scope, key));
+    return undefined;
+  }
+  return entry.value as T;
+}
+
+/** Stores an entry. */
+export function publishedCacheSet(
+  scope: PublishedCacheScope,
+  key: string,
+  value: unknown,
+): void {
+  if (ttlMs === 0) return;
+  store.set(cacheKey(scope, key), { value, expiresAt: Date.now() + ttlMs });
+}
+
+/**
+ * Drops cached content.
+ *
+ * With no arguments every scope is cleared, which is what a write should do:
+ * a saved page can change any global section's resolved output, and clearing
+ * everything can only cost one extra read.
+ */
+export function invalidatePublishedCache(scope?: PublishedCacheScope, key?: string): void {
+  invalidations += 1;
+  if (!scope) {
+    store.clear();
+    return;
+  }
+  if (key) {
+    store.delete(cacheKey(scope, key));
+    return;
+  }
+  const prefix = `${scope}:`;
+  for (const k of [...store.keys()]) if (k.startsWith(prefix)) store.delete(k);
+}
+
+/** Runs `load` only when the entry is missing or expired. */
+export async function withPublishedCache<T>(
+  scope: PublishedCacheScope,
+  key: string,
+  load: () => Promise<T>,
+): Promise<T> {
+  const cached = publishedCacheGet<T>(scope, key);
+  if (cached !== undefined) {
+    hits += 1;
+    return cached;
+  }
+  misses += 1;
+  const value = await load();
+  // `undefined` is indistinguishable from "absent", so it is never stored.
+  if (value !== undefined) publishedCacheSet(scope, key, value);
+  return value;
+}
+
+/** Counters and size, for the backoffice diagnostics screen. */
+export function publishedCacheStats(): {
+  entries: number;
+  hits: number;
+  misses: number;
+  invalidations: number;
+  ttlMs: number;
+} {
+  return { entries: store.size, hits, misses, invalidations, ttlMs };
+}
+
+/** Resets counters and contents. Tests use this between cases. */
+export function resetPublishedCache(): void {
+  store.clear();
+  hits = 0;
+  misses = 0;
+  invalidations = 0;
+}

package/src/site/routes/public-page.tsx

@@ -7,12 +7,12 @@
  * site, so the engine lives here and the site keeps a thin route wrapper.
  */
 import { notFound, redirect } from "@tanstack/react-router";
-import type { ComponentType, ReactNode } from "react";
+import type { ComponentType, ReactElement, ReactNode } from "react";
 
 export type ResolvedPath =
   | { kind: "page"; pageKey: string }
   | { kind: "redirect"; to: string; status?: number }
-  | { kind: "none" };
+  | { kind: "notfound" };
 
 export type PublicPageHead = {
   meta?: Array<Record<string, string>>;
@@ -50,9 +50,9 @@ type LoaderArgs = {
 export type PublicPageRoute<Ctx> = {
   loader: (args: LoaderArgs) => Promise<{ pageKey: string; ctx: Ctx }>;
   head: (args: { loaderData?: { pageKey: string; ctx: Ctx } }) => PublicPageHead;
-  PublicPage: ComponentType<{ pageKey: string }>;
-  ErrorScreen: ComponentType;
-  NotFoundScreen: ComponentType;
+  PublicPage: (props: { pageKey: string }) => ReactElement;
+  ErrorScreen: () => ReactElement;
+  NotFoundScreen: () => ReactElement;
 };
 
 export function createPublicPageRoute<Ctx>(deps: PublicPageRouteDeps<Ctx>): PublicPageRoute<Ctx> {