@bygghammar/cms-platform 0.50.0 → 0.51.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.51.0
+
+- `site/indexing`: environment-derived search-engine policy (`SITE_INDEXING`,
+  falling back to `SITE_ENV`/`NODE_ENV`). Staging is blocked by default.
+- `server/http/robots`: a blocked deployment serves `Disallow: /` with no
+  sitemap line and an `X-Robots-Tag` header.
+- `http/response-headers`: adds `noindex, nofollow, noarchive, nosnippet,
+  noimageindex` to every response of a blocked deployment.
+- `SiteSettingsView`: shows the read-only indexing status, and the company
+  fields are now a read-only summary that points at Settings -> Contact
+  details, which is the single editor for them.
+
+
+## 0.50.1
+
+- `runtime/server-entry`: the injection adapter is typed against `InjectionBundle`, matching the shared `injections-core` helpers exactly.
+
 ## 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.50.0",
+  "version": "0.51.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": [
@@ -196,7 +196,8 @@
     "./runtime/error-page": "./src/runtime/error-page.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"
+    "./runtime/server-entry": "./src/runtime/server-entry.ts",
+    "./site/indexing": "./src/site/indexing.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/backoffice/ContactDetailsView.tsx

@@ -6,12 +6,12 @@ export type ContactField = { key: string; label: string; type?: string };
 
 /** The canonical company detail fields every site shares. */
 export const CONTACT_FIELDS: ContactField[] = [
-  { key: "locationName", label: "Name" },
-  { key: "street", label: "Address" },
+  { key: "locationName", label: "Location name" },
+  { key: "street", label: "Street" },
   { key: "postCode", label: "Post code" },
   { key: "city", label: "City" },
   { key: "country", label: "Country" },
-  { key: "legalName", label: "Company details (legal name)" },
+  { key: "legalName", label: "Legal name" },
   { key: "orgNumber", label: "Org. number" },
   { key: "email", label: "Email", type: "email" },
   { key: "phone", label: "Phone", type: "tel" },
@@ -68,8 +68,9 @@ export function ContactDetailsView({ deps }: { deps: ContactDetailsDeps }) {
       <div className="text-[0.7rem] uppercase tracking-[0.22em] text-ink/55">Settings</div>
       <h2 className="mt-2 font-serif text-3xl text-ink">Contact details</h2>
       <p className="mt-3 text-sm text-ink/65">
-        These company details are the single source of truth. They are used in the website contact
-        section, the footer and the structured data for search engines.
+        These company details are the single source of truth — site settings only shows them for
+        reference. They are used in the website contact section, the footer and the structured data
+        for search engines.
       </p>
 
       <div className="mt-10 grid gap-5 sm:grid-cols-2">

package/src/backoffice/SiteSettingsView.tsx

@@ -9,6 +9,7 @@ import {
   type SiteFeatureFlags,
   type SiteSettingOverrides,
 } from "../config/site-config";
+import type { IndexingPolicy } from "../site/indexing";
 
 export type SiteSettingsDeps = {
   /** Code config with any stored overrides already applied. */
@@ -23,6 +24,19 @@ export type SiteSettingsDeps = {
    * set `SITE_URL` for this deployment; `"code"` means the compiled fallback.
    */
   originSource?: "environment" | "code";
+  /**
+   * Indexing policy for the running deployment, resolved from the environment
+   * server-side (see `site/indexing`). Shown read-only: a staging host must not
+   * be able to open itself to search engines from the backoffice.
+   */
+  indexing?: IndexingPolicy;
+  /**
+   * Live company values as stored by the contact details screen. Falls back to
+   * the config company when omitted.
+   */
+  companyValues?: Record<string, string>;
+  /** Navigate to the contact details screen, where company fields are edited. */
+  onOpenContactDetails?: () => void;
 };
 
 const FEATURE_LABELS: Record<keyof SiteFeatureFlags, string> = {
@@ -58,7 +72,9 @@ const cardClass = "border border-ink/10 bg-white p-6";
  * screen writes only the overridable subset into the database.
  */
 export function SiteSettingsView({ deps }: { deps: SiteSettingsDeps }) {
-  const { config, overrides, saveSettings, clearSetting, refresh } = deps;
+  const { config, overrides, saveSettings, clearSetting, refresh, onOpenContactDetails } = deps;
+  const indexing = deps.indexing;
+  const shownCompany = { ...EMPTY_COMPANY, ...config.company, ...(deps.companyValues ?? {}) };
   const originSource = deps.originSource ?? "code";
   const [name, setName] = useState(config.name);
   const [company, setCompany] = useState({ ...EMPTY_COMPANY, ...config.company });
@@ -119,6 +135,17 @@ export function SiteSettingsView({ deps }: { deps: SiteSettingsDeps }) {
             originSource === "environment" ? "From SITE_URL" : "Code fallback \u2014 SITE_URL unset",
           ],
           ["Locales", config.locales.join(", "), "Set in code"],
+          [
+            "Search engines",
+            indexing ? (indexing.mode === "block" ? "Blocked \u2014 not indexed" : "Indexed") : "Unknown",
+            indexing
+              ? indexing.source === "SITE_INDEXING"
+                ? `From SITE_INDEXING=${indexing.value}`
+                : indexing.source === "SITE_ENV"
+                  ? `From SITE_ENV=${indexing.value}`
+                  : "Safe default \u2014 SITE_INDEXING unset"
+              : "Set SITE_INDEXING per environment",
+          ],
           [
             "Backoffice",
             `${config.backofficePath} (${config.backofficeLocale})`,
@@ -133,9 +160,14 @@ export function SiteSettingsView({ deps }: { deps: SiteSettingsDeps }) {
         ))}
       </dl>
       <p className="mt-3 max-w-2xl text-xs text-ink/50">
-        These four are structural: the locale set and backoffice path are compiled into the build,
+        These are structural: the locale set and backoffice path are compiled into the build,
         and the public origin differs per environment. They are read from code and environment on
-        purpose, so a deployment can never disagree with what the database says.
+        purpose, so a deployment can never disagree with what the database says. Indexing is the
+        same kind of fact: set <code>SITE_INDEXING=off</code> on staging and{" "}
+        <code>SITE_INDEXING=on</code> in production. A blocked deployment serves{" "}
+        <code>Disallow: /</code> in robots.txt and a <code>noindex, nofollow</code> header on every
+        response, so it can never be indexed even if a link leaks. For truly private staging, add
+        HTTP basic auth in Traefik on top — a password is the only thing that keeps humans out.
       </p>
 
       <section className={`mt-8 ${cardClass}`}>
@@ -155,27 +187,29 @@ export function SiteSettingsView({ deps }: { deps: SiteSettingsDeps }) {
       </section>
 
       <section className={`mt-6 ${cardClass}`}>
-        <SectionHeader
-          title="Company & contact details"
-          overridden={overridden("company")}
-          onReset={() => reset("company")}
-          busy={busy === "company"}
-        />
-        <div className="mt-4 grid gap-3 md:grid-cols-3">
+        <h2 className="font-serif text-xl text-ink">Company &amp; contact details</h2>
+        <p className="mt-2 max-w-2xl text-sm text-ink/60">
+          These moved to <strong>Settings &rarr; Contact details</strong>, which is the single place
+          they are edited. The values there feed the website contact section, the footer and the
+          structured data for search engines.
+        </p>
+        <dl className="mt-4 grid gap-3 md:grid-cols-3">
           {(Object.keys(COMPANY_LABELS) as (keyof typeof EMPTY_COMPANY)[]).map((key) => (
-            <label key={key} className="block">
-              <span className={labelClass}>{COMPANY_LABELS[key]}</span>
-              <input
-                className={inputClass}
-                value={company[key] ?? ""}
-                onChange={(e) => setCompany({ ...company, [key]: e.target.value })}
-              />
-            </label>
+            <div key={key}>
+              <dt className={labelClass}>{COMPANY_LABELS[key]}</dt>
+              <dd className="text-sm text-ink">{shownCompany[key] || <span className="text-ink/35">Not set</span>}</dd>
+            </div>
           ))}
-        </div>
-        <div className="mt-4">
-          <SaveButton busy={busy === "company"} onClick={() => save("company", { company })} />
-        </div>
+        </dl>
+        {onOpenContactDetails ? (
+          <button
+            type="button"
+            onClick={onOpenContactDetails}
+            className="mt-5 bg-ink px-5 py-2.5 text-xs uppercase tracking-[0.22em] text-paper"
+          >
+            Edit contact details
+          </button>
+        ) : null}
       </section>
 
       <section className={`mt-6 ${cardClass}`}>

package/src/backoffice/routes/index.tsx

@@ -128,11 +128,20 @@ export function VersionRoute() {
 
 /** Site settings screen (code defaults plus database overrides). */
 export function SiteSettingsRoute() {
-  const { fns, siteConfig } = backofficeHost();
+  const host = backofficeHost();
+  const { fns, siteConfig, company } = host;
   const load = useServerFn(fns.getSiteSettings);
   const save = useServerFn(fns.saveSiteSettings);
   const clear = useServerFn(fns.clearSiteSetting);
+  const fetchOverrides = useServerFn(fns.getContentOverrides);
   const q = useQuery({ queryKey: ["admin", "site-settings"], queryFn: () => load() });
+  // Company fields are owned by the contact details screen (a content
+  // override), so read them from the same place for the read-only summary.
+  const contactQ = useQuery({
+    queryKey: ["cms", "content-overrides"],
+    queryFn: () => fetchOverrides(),
+  });
+  const contactPath = backofficePaths(host).contact;
 
   return (
     <SiteSettingsView
@@ -143,6 +152,14 @@ export function SiteSettingsRoute() {
         clearSetting: (input) => clear(input as never),
         refresh: () => q.refetch(),
         originSource: q.data?.originSource ?? "code",
+        indexing: q.data?.indexing,
+        companyValues: {
+          ...company,
+          ...((contactQ.data?.company as Record<string, string> | undefined) ?? {}),
+        },
+        onOpenContactDetails: () => {
+          window.location.href = contactPath;
+        },
       }}
     />
   );

package/src/http/response-headers.ts

@@ -8,6 +8,7 @@
  * `Content-Encoding`) and keeps a bare `docker compose up` correct too.
  */
 
+import { NOINDEX_HEADER, indexingBlocked } from "../site/indexing";
 import { createMiddleware } from "@tanstack/react-start";
 
 import { cachePolicyFor, expiresHeader } from "./cache-policy";
@@ -73,6 +74,13 @@ export async function applyEdgeHeaders(
   }
   dedupeVary(headers);
 
+  // 2b. Indexing policy. Staging deployments must never be indexed, and the
+  //     header covers every response type (HTML, media, JSON) — robots.txt
+  //     alone does not deindex a URL that was already crawled.
+  if (!headers.has("x-robots-tag") && indexingBlocked()) {
+    headers.set("x-robots-tag", NOINDEX_HEADER);
+  }
+
   // 3. Compression.
   if (
     !compress ||

package/src/runtime/server-entry.ts

@@ -14,21 +14,15 @@ import "./error-capture";
 import { consumeLastCapturedError } from "./error-capture";
 import { renderErrorPage } from "./error-page";
 import { applyEdgeHeaders } from "../http/response-headers";
+import type { InjectionBundle } from "../tracking/injections";
 
 export type SiteCodeInjections = {
   /** Whether backoffice-managed code may be injected on this path. */
-  isInjectablePath: (pathname: string) => boolean;
+  isInjectablePath: (pathname: string, backofficePath?: string) => boolean;
   /** Head / body-start / body-end snippets for the requesting host. */
-  resolve: (host: string) => Promise<{
-    head?: string;
-    bodyStart?: string;
-    bodyEnd?: string;
-  }>;
+  resolve: (host: string) => Promise<InjectionBundle>;
   /** Applies a resolved bundle to the rendered HTML. */
-  apply: (
-    html: string,
-    bundle: { head?: string; bodyStart?: string; bodyEnd?: string },
-  ) => string;
+  apply: (html: string, bundle: InjectionBundle) => string;
 };
 
 export type ServerEntryOptions = {

package/src/server/http/robots.ts

@@ -5,6 +5,9 @@
  * own default domain — a static file in `public/` goes stale the moment the
  * domain changes.
  */
+
+import { resolveIndexingPolicy, type IndexingMode } from "../../site/indexing";
+
 export type RobotsOptions = {
   /** The incoming request URL, used as the host fallback. */
   requestUrl: string;
@@ -16,6 +19,11 @@ export type RobotsOptions = {
   allowedAgents?: string[];
   /** `Cache-Control` for the response. */
   cacheControl?: string;
+  /**
+   * Override the environment-derived indexing policy. Leave unset so staging
+   * hosts (`SITE_INDEXING=off`) automatically serve a full disallow.
+   */
+  indexing?: IndexingMode;
 };
 
 export const DEFAULT_ALLOWED_AGENTS = [
@@ -26,6 +34,18 @@ export const DEFAULT_ALLOWED_AGENTS = [
 ];
 
 export async function robotsResponse(options: RobotsOptions): Promise<Response> {
+  const mode = options.indexing ?? resolveIndexingPolicy().mode;
+  if (mode === "block") {
+    // A blocked deployment advertises nothing: no sitemap, no per-agent allows.
+    return new Response(["User-agent: *", "Disallow: /", ""].join("\n"), {
+      headers: {
+        "Content-Type": "text/plain; charset=utf-8",
+        "Cache-Control": "public, max-age=300",
+        "X-Robots-Tag": "noindex, nofollow",
+      },
+    });
+  }
+
   let host = new URL(options.requestUrl).host;
   if (options.resolvePreferredHost) {
     try {

package/src/site/indexing.ts

@@ -0,0 +1,55 @@
+/**
+ * Search-engine indexing policy — an environment fact, never a database value.
+ *
+ * Staging and production run the same build, so whether a deployment may be
+ * indexed cannot live in content or in `site_settings`: a content restore or a
+ * database copy would then silently open staging to Google, or close
+ * production. It is read from `SITE_INDEXING` (or `SITE_ENV`) at request time.
+ *
+ * `SITE_INDEXING`:
+ *   `off` | `block` | `noindex` | `0` | `false` → blocked
+ *   `on`  | `allow` | `index`   | `1` | `true`  → allowed
+ * Unset falls back to `SITE_ENV` / `NODE_ENV`: anything that is not
+ * `production` is blocked, which is the safe default for a fresh staging host.
+ */
+export type IndexingMode = "allow" | "block";
+
+export type IndexingPolicy = {
+  mode: IndexingMode;
+  /** Where the decision came from, for display in the backoffice. */
+  source: "SITE_INDEXING" | "SITE_ENV" | "default";
+  /** The raw value behind the decision, e.g. `off` or `staging`. */
+  value: string;
+};
+
+/** `X-Robots-Tag` sent on every response of a blocked deployment. */
+export const NOINDEX_HEADER = "noindex, nofollow, noarchive, nosnippet, noimageindex";
+
+const BLOCK = new Set(["off", "block", "blocked", "noindex", "no", "0", "false"]);
+const ALLOW = new Set(["on", "allow", "allowed", "index", "yes", "1", "true"]);
+
+type Env = Record<string, string | undefined>;
+
+export function resolveIndexingPolicy(env: Env = process.env): IndexingPolicy {
+  const explicit = (env["SITE_INDEXING"] ?? "").trim().toLowerCase();
+  if (explicit) {
+    if (BLOCK.has(explicit)) return { mode: "block", source: "SITE_INDEXING", value: explicit };
+    if (ALLOW.has(explicit)) return { mode: "allow", source: "SITE_INDEXING", value: explicit };
+  }
+
+  const environment = (env["SITE_ENV"] ?? env["NODE_ENV"] ?? "").trim().toLowerCase();
+  if (environment) {
+    return {
+      mode: environment === "production" ? "allow" : "block",
+      source: "SITE_ENV",
+      value: environment,
+    };
+  }
+
+  return { mode: "block", source: "default", value: "unset" };
+}
+
+/** True when this deployment must not be indexed. */
+export function indexingBlocked(env: Env = process.env): boolean {
+  return resolveIndexingPolicy(env).mode === "block";
+}