@bygghammar/cms-platform 0.93.0 → 0.95.0

package/src/site/route-aliases.ts

@@ -0,0 +1,74 @@
+/**
+ * Every address that reaches each page, the way the path resolver sees them.
+ *
+ * Hiding links to an unlisted page has to recognise all of its addresses — the
+ * Swedish slug, the English one under `/en`, a slug changed in the SEO screen,
+ * the bare `/<key>` every builder page answers to — and none that belong to a
+ * different page. This builds the same map `resolvePathCore` consults, in the
+ * same order of precedence:
+ *
+ * 1. slug overrides from `page_seo`;
+ * 2. the site's static page registry, for pages with no override;
+ * 3. the bare key, `/<key>` and `/<locale>/<key>`, for pages that exist, only
+ *    where no slug already claims the address.
+ *
+ * Within one precedence level the first page (in key order) wins an address,
+ * matching the resolver's "first entered wins" for the rare collision instead
+ * of guessing differently.
+ */
+import { normalizeRoutePath, servedPath } from "./route-index";
+
+/** Slug map of a page in a site's static registry (as `resolvePathCore` takes it). */
+export type AliasSlugRegistry = Record<string, { slug: Record<string, string | undefined> }>;
+
+export type RouteAliasInput = {
+  /** The site's static page registry. */
+  registry: AliasSlugRegistry;
+  /** `page_seo.slugs` per page key, for pages that have a row. */
+  overrides: ReadonlyMap<string, Record<string, string | undefined>>;
+  /** Keys of CMS pages that exist (not in the trash): their `/<key>` answers too. */
+  existingKeys: readonly string[];
+  locales: readonly string[];
+  defaultLocale: string;
+  /** The locale an unprefixed address resolves in on this request's domain. */
+  requestLocale: string;
+};
+
+const BARE_KEY = /^[a-z0-9_-]+$/;
+
+/** Normalized served path → the page key the resolver would answer with. */
+export function routeAliasMap(input: RouteAliasInput): Map<string, string> {
+  const policy = { locales: input.locales };
+  const prefixed = input.locales.filter((locale) => locale !== input.defaultLocale);
+  const map = new Map<string, string>();
+  const claim = (path: string, key: string) => {
+    const normalized = normalizeRoutePath(path, policy);
+    if (!map.has(normalized)) map.set(normalized, key);
+  };
+
+  const slugPaths = (key: string, slugs: Record<string, string | undefined>) => {
+    const pick = (locale: string) => slugs[locale] ?? slugs[input.defaultLocale];
+    // Unprefixed: the slug of the locale this domain resolves bare paths in.
+    const bare = pick(input.requestLocale);
+    if (bare !== undefined && bare !== null) claim(servedPath(bare, input.defaultLocale, input.defaultLocale), key);
+    // Prefixed: every other locale, each under its own prefix.
+    for (const locale of prefixed) {
+      const slug = pick(locale);
+      if (slug !== undefined && slug !== null) claim(servedPath(slug, locale, input.defaultLocale), key);
+    }
+  };
+
+  for (const key of [...input.overrides.keys()].sort()) {
+    slugPaths(key, input.overrides.get(key) ?? {});
+  }
+  for (const key of Object.keys(input.registry).sort()) {
+    if (input.overrides.has(key)) continue;
+    slugPaths(key, input.registry[key]!.slug);
+  }
+  for (const key of [...input.existingKeys].sort()) {
+    if (!BARE_KEY.test(key)) continue;
+    claim(`/${key}`, key);
+    for (const locale of input.locales) claim(`/${locale}/${key}`, key);
+  }
+  return map;
+}

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

@@ -43,8 +43,42 @@ export type PreviewPageDeps = {
   /** Outline colour used for block hover/selection. */
   outlineColorVar?: string;
   copy?: { draft?: string; published?: string; loading?: string };
+  /**
+   * What a visitor would get, for the standalone Preview: a hook returning a
+   * transform the site applies to the blocks it shows (booking links removed
+   * while booking is off, say). Never applied inside the builder's own canvas,
+   * which keeps every block and link editable.
+   */
+  usePublicView?: () => (
+    pageKey: string,
+    snapshot: { blocks: BlockInstance[]; globals: Record<string, BlockInstance[]> },
+  ) => { blocks: BlockInstance[]; globals: Record<string, BlockInstance[]> };
 };
 
+/**
+ * Where a preview is being rendered.
+ *
+ * `canvas` is the builder's own editing surface, embedded in the builder; it
+ * shows every block as authored. `preview` is the page opened on its own and
+ * follows the public policy. The mode comes from how the page is actually
+ * displayed — never from a query parameter — and nothing about it grants
+ * access: unpublished content still only arrives from the editor's own
+ * browser or through staff-only reads.
+ */
+export type PreviewRenderMode = "canvas" | "preview";
+
+export function previewRenderMode(
+  win: { parent: unknown } | undefined = typeof window === "undefined" ? undefined : window,
+): PreviewRenderMode {
+  return win !== undefined && win.parent !== win ? "canvas" : "preview";
+}
+
+const asIs = (
+  _key: string,
+  snapshot: { blocks: BlockInstance[]; globals: Record<string, BlockInstance[]> },
+) => snapshot;
+const useAsIs = () => asIs;
+
 type DraftMsg = {
   source: "lovable-editor";
   type: "draft" | "scrollTo";
@@ -72,7 +106,9 @@ export function createPreviewPage(deps: PreviewPageDeps): ComponentType<{ pageKe
     const [locale, setLocale] = useState<Locale>(DEFAULT_LOCALE);
     const [ready, setReady] = useState(false);
     const [isDraft, setIsDraft] = useState(false);
-    const embedded = typeof window !== "undefined" && window.parent !== window;
+    const embedded = previewRenderMode() === "canvas";
+    const publicView = (deps.usePublicView ?? useAsIs)();
+    const shown = embedded ? { blocks, globals } : publicView(key, { blocks, globals });
 
     // Bootstrap: prefer a local unsaved draft, else the saved version.
     useEffect(() => {
@@ -225,8 +261,8 @@ export function createPreviewPage(deps: PreviewPageDeps): ComponentType<{ pageKe
               : "pt-24 md:pt-32 has-[[data-site-hero]]:pt-0 md:has-[[data-site-hero]]:pt-0"}>
             {ready ? (
               <deps.DraftPageRenderer
-                blocks={blocks}
-                globals={globals}
+                blocks={shown.blocks}
+                globals={shown.globals}
                 edit
                 selectedId={selectedId}
               />

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

@@ -26,8 +26,12 @@ export type PublicPageRouteDeps<Ctx> = {
   resolvePath: (path: string) => Promise<ResolvedPath>;
   /** Page-context query (SEO rows, locale, origin, domains). */
   pageContextQueryOptions: QueryLike;
-  /** Published-page query for one page key. */
-  pageQueryOptions: (pageKey: string) => QueryLike;
+  /**
+   * Published-page query for one page key. With `pagePolicy` configured it is
+   * also handed the page's current policy, so a site can keep pages fetched
+   * under different policies in different cache entries.
+   */
+  pageQueryOptions: (pageKey: string, pagePolicy?: unknown) => QueryLike;
   /** Head builder from `createPageContext`. */
   buildPageHead: (pageKey: string, context: Ctx | undefined) => PublicPageHead;
   /** Site chrome. */
@@ -39,17 +43,60 @@ export type PublicPageRouteDeps<Ctx> = {
   copy: { notFoundTitle: string; errorText: string };
   /** Padding applied above the page content; defaults to the header offset. */
   contentClassName?: string;
+  /**
+   * This page's public policy, read on the server: a query resolving to at
+   * least `{ indexable: boolean }`. A page that is reachable but not listed
+   * (link-only), or whose policy could not be read, is rendered with
+   * `noindex`. The answer is handed to the page as `pagePolicy` in the loader
+   * data, so the page can apply the rest of it (booking, say).
+   *
+   * Per page on purpose: a site-wide list would put the address of every
+   * link-only page into the source of every page. Optional: without it every
+   * page found is indexable as before. Reachability itself stays with
+   * `pageQueryOptions`, which answers nothing for a page that is not public.
+   */
+  pagePolicy?: (pageKey: string) => QueryLike;
+};
+
+/** The part of a page policy the route itself reads. */
+export type RoutePagePolicy = {
+  /** False: render with `noindex`. */
+  indexable?: boolean;
+  /** True: the page exists and is positively not public now. Answer 404 whatever the cache holds. */
+  offline?: boolean;
+  /** True: the page is public now. A cached "not found" is re-read rather than trusted. */
+  live?: boolean;
 };
 
 type EnsureQueryData = <T extends QueryLike>(options: T) => Promise<unknown>;
 type LoaderArgs = {
-  context: { queryClient: { ensureQueryData: EnsureQueryData } };
+  context: {
+    queryClient: {
+      ensureQueryData: EnsureQueryData;
+      /** Honours the query's freshness, so client navigation re-reads a stale policy. */
+      fetchQuery?: EnsureQueryData;
+    };
+  };
   params: { _splat?: string };
 };
 
+/** What the route hands its head and component. */
+export type PublicPageLoaderData<Ctx> = { pageKey: string; ctx: Ctx; pagePolicy?: unknown };
+
+/** A head with its robots directive replaced by `noindex` — never weakened, only added. */
+export function withNoindex(head: PublicPageHead): PublicPageHead {
+  return {
+    ...head,
+    meta: [
+      ...(head.meta ?? []).filter((tag) => tag["name"] !== "robots"),
+      { name: "robots", content: "noindex" },
+    ],
+  };
+}
+
 export type PublicPageRoute<Ctx> = {
-  loader: (args: LoaderArgs) => Promise<{ pageKey: string; ctx: Ctx }>;
-  head: (args: { loaderData?: { pageKey: string; ctx: Ctx } }) => PublicPageHead;
+  loader: (args: LoaderArgs) => Promise<PublicPageLoaderData<Ctx>>;
+  head: (args: { loaderData?: PublicPageLoaderData<Ctx> }) => PublicPageHead;
   PublicPage: (props: { pageKey: string }) => ReactElement;
   ErrorScreen: () => ReactElement;
   NotFoundScreen: () => ReactElement;
@@ -73,10 +120,32 @@ export function createPublicPageRoute<Ctx>(deps: PublicPageRouteDeps<Ctx>): Publ
       }
       if (res.kind !== "page") throw notFound();
 
-      const [ctx, page] = await Promise.all([
+      const fetchQuery = context.queryClient.fetchQuery?.bind(context.queryClient);
+      const readPolicy = deps.pagePolicy
+        ? (fetchQuery ?? context.queryClient.ensureQueryData.bind(context.queryClient))(
+            deps.pagePolicy(res.pageKey),
+          )
+        : Promise.resolve(undefined);
+      // The policy first: it decides whether a cached page may be used at all,
+      // and which cache entry to read.
+      const [ctx, pagePolicy] = await Promise.all([
         context.queryClient.ensureQueryData(deps.pageContextQueryOptions),
-        context.queryClient.ensureQueryData(deps.pageQueryOptions(res.pageKey)),
+        readPolicy,
       ]);
+      const policy = pagePolicy as RoutePagePolicy | undefined;
+      /*
+       * A page the current policy reports offline answers 404 even when the
+       * browser still holds it from a visit made while it was published. A
+       * warm query must not keep an unpublished page on the screen.
+       */
+      if (policy?.offline === true) throw notFound();
+      const pageOptions = deps.pageQueryOptions(res.pageKey, pagePolicy);
+      let page = await context.queryClient.ensureQueryData(pageOptions);
+      // And the reverse: a "not found" cached before the page went live is
+      // read again rather than trusted.
+      if (page == null && policy?.live === true && fetchQuery) {
+        page = await fetchQuery({ ...pageOptions, staleTime: 0 } as QueryLike);
+      }
 
       /*
        * `resolvePath` only knows the path map, which lists drafts too. The
@@ -88,7 +157,7 @@ export function createPublicPageRoute<Ctx>(deps: PublicPageRouteDeps<Ctx>): Publ
        * path.
        */
       if (page == null) throw notFound();
-      return { pageKey: res.pageKey, ctx: ctx as Ctx };
+      return { pageKey: res.pageKey, ctx: ctx as Ctx, pagePolicy };
     },
 
     head({ loaderData }) {
@@ -97,7 +166,10 @@ export function createPublicPageRoute<Ctx>(deps: PublicPageRouteDeps<Ctx>): Publ
           meta: [{ title: deps.copy.notFoundTitle }, { name: "robots", content: "noindex" }],
         };
       }
-      return deps.buildPageHead(loaderData.pageKey, loaderData.ctx);
+      const head = deps.buildPageHead(loaderData.pageKey, loaderData.ctx);
+      // Link-only (or a policy that could not be read): reachable, not indexable.
+      const policy = loaderData.pagePolicy as RoutePagePolicy | undefined;
+      return policy?.indexable === false ? withNoindex(head) : head;
     },
 
     PublicPage: ({ pageKey }) => (