@bygghammar/cms-platform 0.57.0 → 0.58.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.58.0
+
+- Utilities sweep: the public-page context loader (`site/page-context`), the
+  deployment origin resolver (`site/public-origin`), the self-hosted font bundle
+  (`site/font-bundle`) and the version screen's build/release metadata
+  (`admin/version-core`) are now package-owned factories. Sites pass their own
+  data sources, compiled origin and font assets.
+- New drift guard: `config/package-owned-modules` lists every module a site must
+  keep as a thin wrapper, so a site test fails the build if platform behaviour is
+  reimplemented locally.
+
 ## 0.57.0
 
 - Server-function inputs are now platform contracts: `server/schemas` ships the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.57.0",
+  "version": "0.58.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": [
@@ -172,6 +172,11 @@
     "./backoffice/ResetPasswordView": "./src/backoffice/ResetPasswordView.tsx",
     "./backoffice/routes/pages": "./src/backoffice/routes/pages.tsx",
     "./config/define-site": "./src/config/define-site.ts",
+    "./site/page-context": "./src/site/page-context.ts",
+    "./site/public-origin": "./src/site/public-origin.ts",
+    "./site/font-bundle": "./src/site/font-bundle.ts",
+    "./admin/version-core": "./src/admin/version-core.ts",
+    "./config/package-owned-modules": "./src/config/package-owned-modules.ts",
     "./server/schema-drift": "./src/server/schema-drift.ts",
     "./server/media-focus-core": "./src/server/media-focus-core.ts",
     "./server/media-meta-core": "./src/server/media-meta-core.ts",

package/src/admin/version-core.ts

@@ -0,0 +1,76 @@
+/**
+ * Build metadata and platform release history for the version screen.
+ *
+ * The build constants are injected by the site's Vite config (they must be, the
+ * values only exist at build time); reading them defensively and fetching the
+ * package's published releases is identical everywhere, so it lives here.
+ */
+
+export type BuildInfo = {
+  appVersion: string;
+  buildTime: string;
+  platformVersion: string;
+  platformRange: string;
+};
+
+export type PlatformRelease = {
+  version: string;
+  publishedAt: string | null;
+  current: boolean;
+};
+
+/** Raw build constants as provided by the host build. */
+export type BuildConstants = {
+  appVersion?: unknown;
+  buildTime?: unknown;
+  platformVersion?: unknown;
+  platformRange?: unknown;
+};
+
+const text = (value: unknown, fallback: string): string =>
+  typeof value === "string" && value ? value : fallback;
+
+/** Normalize the injected build constants into a complete `BuildInfo`. */
+export function readBuildInfoFrom(constants: BuildConstants): BuildInfo {
+  return {
+    appVersion: text(constants.appVersion, "0.0.0"),
+    buildTime: text(constants.buildTime, new Date().toISOString()),
+    platformVersion: text(constants.platformVersion, "unknown"),
+    platformRange: text(constants.platformRange, "unknown"),
+  };
+}
+
+/** The npm package name of the shared CMS platform. */
+export const PLATFORM_PACKAGE = "@bygghammar/cms-platform";
+
+/**
+ * The most recent published platform releases, newest first.
+ *
+ * Network failures are not an error worth surfacing on an information screen —
+ * the screen still shows the running version from the build constants.
+ */
+export async function fetchPlatformReleases(
+  currentVersion: string,
+  limit = 3,
+): Promise<PlatformRelease[]> {
+  try {
+    const res = await fetch(
+      `https://registry.npmjs.org/${PLATFORM_PACKAGE.replace("/", "%2F")}`,
+      { headers: { accept: "application/json" } },
+    );
+    if (!res.ok) return [];
+    const json = (await res.json()) as { time?: Record<string, string> };
+    const time = json.time ?? {};
+    return Object.entries(time)
+      .filter(([v]) => v !== "created" && v !== "modified")
+      .map(([version, publishedAt]) => ({
+        version,
+        publishedAt,
+        current: version === currentVersion,
+      }))
+      .sort((a, b) => (a.publishedAt < b.publishedAt ? 1 : -1))
+      .slice(0, limit);
+  } catch {
+    return [];
+  }
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Drift guard manifest.
+ *
+ * Each entry names a module a site is expected to keep as a thin wrapper, and
+ * the package export it must delegate to. A site test walks this manifest and
+ * fails the build when a local file stops importing the package module — the
+ * failure mode this whole extraction exists to prevent, where a site quietly
+ * reimplements platform behaviour and then drifts away from every other site.
+ */
+
+export type OwnedModule = {
+  /** Path relative to the site's project root. */
+  site: string;
+  /** Package specifier the site file must reference. */
+  packageModule: string;
+  /** Whether the site is allowed not to have the file at all. */
+  optional?: boolean;
+};
+
+export const PACKAGE_OWNED_MODULES: OwnedModule[] = [
+  { site: "src/lib/i18n/routes.ts", packageModule: "@bygghammar/cms-platform/site/routes" },
+  {
+    site: "src/lib/i18n/page-context.ts",
+    packageModule: "@bygghammar/cms-platform/site/page-context",
+  },
+  {
+    site: "src/lib/site/public-origin.ts",
+    packageModule: "@bygghammar/cms-platform/site/public-origin",
+  },
+  { site: "src/lib/site/site-url.ts", packageModule: "@bygghammar/cms-platform/site/site-url" },
+  { site: "src/lib/fonts/bundle.ts", packageModule: "@bygghammar/cms-platform/site/font-bundle" },
+  {
+    site: "src/lib/admin/version.server.ts",
+    packageModule: "@bygghammar/cms-platform/admin/version-core",
+  },
+  {
+    site: "src/lib/backup/backup.server.ts",
+    packageModule: "@bygghammar/cms-platform/server/backup-core",
+  },
+  {
+    site: "src/components/site/SiteHeader.tsx",
+    packageModule: "@bygghammar/cms-platform/site/SiteHeader",
+  },
+  {
+    site: "src/components/site/SiteFooter.tsx",
+    packageModule: "@bygghammar/cms-platform/site/SiteFooter",
+  },
+  {
+    site: "src/components/site/PageRenderer.tsx",
+    packageModule: "@bygghammar/cms-platform/site/PageRenderer",
+  },
+  {
+    site: "src/components/site/blocks/FormBlock.tsx",
+    packageModule: "@bygghammar/cms-platform/blocks/components/FormBlock",
+  },
+  {
+    site: "src/components/site/blocks/CourseListBlock.tsx",
+    packageModule: "@bygghammar/cms-platform/blocks/components/TripListBlock",
+    optional: true,
+  },
+  { site: "src/lib/blocks/registry.tsx", packageModule: "@bygghammar/cms-platform/blocks/registry" },
+  { site: "src/lib/site/definition.ts", packageModule: "@bygghammar/cms-platform/config/define-site" },
+];

package/src/server/schemas.ts

@@ -85,11 +85,11 @@ export const pageSchemas = {
  * Administration inputs. Roles and provider kinds come from the platform's
  * own enums, which the caller passes so a site cannot drift from them.
  */
-export function adminSchemas(input: {
-  roles: readonly [string, ...string[]];
-  providerKinds: readonly [string, ...string[]];
+export function adminSchemas<R extends string, K extends string>(input: {
+  roles: readonly [R, ...R[]];
+  providerKinds: readonly [K, ...K[]];
 }) {
-  const role = z.enum(input.roles);
+  const role = z.enum(input.roles as unknown as [R, ...R[]]);
   return {
     role,
     createUser: z.object({
@@ -114,7 +114,7 @@ export function adminSchemas(input: {
     emailProvider: z.object({
       id: uuid.optional(),
       name: z.string().min(1).max(120),
-      kind: z.enum(input.providerKinds),
+      kind: z.enum(input.providerKinds as unknown as [K, ...K[]]),
       is_active: z.boolean().default(true),
       sort_order: z.number().int().min(0).max(9999).default(100),
       from_name: z.string().max(200).nullable().optional(),
@@ -209,9 +209,9 @@ const localizedImage = z
  * everything else — the localized string/image shape, the allowed Open Graph
  * and Twitter values, the slug map — is a platform contract.
  */
-export function pageSeoSchemas(input: {
-  pageKeys: readonly [string, ...string[]];
-  locales: readonly [string, ...string[]];
+export function pageSeoSchemas<P extends string, L extends string>(input: {
+  pageKeys: readonly [P, ...P[]];
+  locales: readonly [L, ...L[]];
 }) {
   const seo = z
     .object({
@@ -224,7 +224,7 @@ export function pageSeoSchemas(input: {
       twitterCard: z.enum(["summary", "summary_large_image"]).optional(),
       keywords: localizedString.optional(),
       robots: z.string().max(120).optional(),
-      jsonLd: z.record(z.enum(input.locales), z.record(z.string(), z.unknown())).optional(),
+      jsonLd: z.record(z.enum(input.locales as unknown as [L, ...L[]]), z.record(z.string(), z.unknown())).optional(),
     })
     .strict();
 
@@ -233,8 +233,8 @@ export function pageSeoSchemas(input: {
   return {
     seo,
     slugs,
-    save: z.object({ pageKey: z.enum(input.pageKeys), slugs, seo }),
-    delete: z.object({ pageKey: z.enum(input.pageKeys) }),
+    save: z.object({ pageKey: z.enum(input.pageKeys as unknown as [P, ...P[]]), slugs, seo }),
+    delete: z.object({ pageKey: z.enum(input.pageKeys as unknown as [P, ...P[]]) }),
   } as const;
 }
 

package/src/site/font-bundle.ts

@@ -0,0 +1,43 @@
+/**
+ * Self-hosted WOFF2 payloads, bundled into the server build.
+ *
+ * Fonts deliberately do NOT live in `public/`: files served by the framework's
+ * static-asset handler bypass every application layer, so they come back without
+ * `Cache-Control` and without `Expires`. Serving them from a real route puts them
+ * back under the deployment's caching policy in both runtimes.
+ *
+ * The site imports its own `.woff2?inline` assets (they are brand assets) and
+ * hands the resulting data URIs to this factory; decoding and caching are shared.
+ */
+
+export type FontBundle = {
+  /** Every filename this bundle can serve. */
+  filenames: string[];
+  /** Font bytes, decoded once per process. `undefined` for unknown names. */
+  fontBytes: (name: string) => Uint8Array | undefined;
+};
+
+function fromDataUri(uri: string): Uint8Array {
+  const base64 = uri.slice(uri.indexOf(",") + 1);
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+
+/** Build a font bundle from a `filename -> data URI` map. */
+export function createFontBundle(dataUris: Record<string, string>): FontBundle {
+  const decoded = new Map<string, Uint8Array>();
+  return {
+    filenames: Object.keys(dataUris),
+    fontBytes(name: string): Uint8Array | undefined {
+      const cached = decoded.get(name);
+      if (cached) return cached;
+      const uri = dataUris[name];
+      if (!uri) return undefined;
+      const bytes = fromDataUri(uri);
+      decoded.set(name, bytes);
+      return bytes;
+    },
+  };
+}

package/src/site/page-context.ts

@@ -0,0 +1,87 @@
+/**
+ * Public-page context: the single server round-trip every public route needs.
+ *
+ * A public page needs four facts before it can render its `<head>`: the CMS SEO
+ * overrides, the locale implied by the request domain, the request origin, and
+ * the locale/domain map used for cross-domain hreflang. Fetching them one by one
+ * per route is what made this glue site-local; the engine is identical for every
+ * site, so it lives here and the site supplies only its data sources.
+ */
+import { queryOptions } from "@tanstack/react-query";
+
+import type { Locale } from "../i18n/locales";
+import type { PageHead, PageSeoOverrides, SiteRoutes } from "./routes";
+
+/** One `locale -> domain` mapping row, as stored by the domains module. */
+export type PageContextDomain = { locale: string; domain: string };
+
+export type PageContext<Row = unknown> = {
+  seoRows: Row[];
+  locale: Locale;
+  origin: string;
+  domains: PageContextDomain[];
+};
+
+export type PageContextDeps<Row> = {
+  /** Raw `page_seo` rows for this site. */
+  getSeoRows: () => Promise<Row[]>;
+  /** Locale + origin derived from the incoming request. */
+  getRequestLocale: () => Promise<{ locale: Locale; origin: string }>;
+  /** Configured locale domains. */
+  getLocaleDomains: () => Promise<PageContextDomain[]>;
+  /** Convert stored rows into the routing engine's override shape. */
+  rowsToOverrides: (rows: Row[] | undefined) => PageSeoOverrides;
+  /** The site's routing engine (from `createSiteRoutes`). */
+  routes: Pick<SiteRoutes, "resolveRoute" | "pageHeadMeta">;
+  /** Locale used when nothing else is known. */
+  defaultLocale: Locale;
+  /** Query key; defaults to `["page-context"]`. */
+  queryKey?: readonly unknown[];
+  /** Cache lifetime in ms; defaults to one minute. */
+  staleTime?: number;
+};
+
+export type SitePageContext<Row> = {
+  pageContextQueryOptions: ReturnType<typeof queryOptions<PageContext<Row>>>;
+  buildPageHead: (pageKey: string, context: PageContext<Row> | undefined) => PageHead;
+  canonicalPathFor: (pageKey: string, context: PageContext<Row> | undefined) => string;
+};
+
+/** Build the page-context loader + head helpers for one site. */
+export function createPageContext<Row>(deps: PageContextDeps<Row>): SitePageContext<Row> {
+  async function fetchPageContext(): Promise<PageContext<Row>> {
+    const [seoRows, localeInfo, domains] = await Promise.all([
+      deps.getSeoRows(),
+      deps.getRequestLocale(),
+      deps.getLocaleDomains(),
+    ]);
+    return {
+      seoRows,
+      locale: localeInfo.locale,
+      origin: localeInfo.origin,
+      domains,
+    };
+  }
+
+  const options = queryOptions<PageContext<Row>>({
+    queryKey: deps.queryKey ?? ["page-context"],
+    queryFn: fetchPageContext,
+    staleTime: deps.staleTime ?? 60_000,
+  });
+
+  function buildPageHead(pageKey: string, context: PageContext<Row> | undefined): PageHead {
+    const locale = context?.locale ?? deps.defaultLocale;
+    const origin = context?.origin ?? "";
+    const overrides = deps.rowsToOverrides(context?.seoRows);
+    const domains = context?.domains ?? [];
+    return deps.routes.pageHeadMeta(pageKey, locale, origin, overrides, domains);
+  }
+
+  function canonicalPathFor(pageKey: string, context: PageContext<Row> | undefined): string {
+    const locale = context?.locale ?? deps.defaultLocale;
+    const overrides = deps.rowsToOverrides(context?.seoRows);
+    return deps.routes.resolveRoute(pageKey, locale, overrides);
+  }
+
+  return { pageContextQueryOptions: options, buildPageHead, canonicalPathFor };
+}

package/src/site/public-origin.ts

@@ -0,0 +1,47 @@
+/**
+ * The canonical public origin for a deployment.
+ *
+ * The origin is a deployment fact, not editable content: preview, staging and
+ * production are different hosts. It is read from the environment, with the
+ * origin compiled into the site's source as the fallback, and is deliberately
+ * never stored as a database override — canonical URLs, sitemaps and auth
+ * redirects must be right before any database read happens.
+ */
+import { originIsFromEnvironment, resolveSiteOrigin } from "../config/site-config";
+
+export type PublicOriginDeps = {
+  /** Origin compiled into the build; used whenever no environment value is set. */
+  codeOrigin: string;
+  /** Reads the configured origin from the environment, or `undefined`. */
+  readEnvOrigin: () => string | undefined;
+};
+
+export type PublicOrigin = {
+  /** The origin this deployment should advertise. Always returns something. */
+  publicOrigin: () => string;
+  /**
+   * The origin this deployment was EXPLICITLY configured with, or `null`.
+   *
+   * Distinct from `publicOrigin()`: a deployment with no configuration is not
+   * the live site, it is a deployment whose configuration is missing. Answering
+   * that from a constant would make every unconfigured build claim to be
+   * production — the one answer that must never be reached by default.
+   */
+  configuredPublicOrigin: () => string | null;
+  /** Whether the running origin came from the environment rather than code. */
+  publicOriginFromEnv: () => boolean;
+};
+
+/** Build the origin accessors for one deployment. */
+export function createPublicOrigin(deps: PublicOriginDeps): PublicOrigin {
+  return {
+    publicOrigin: () => resolveSiteOrigin(deps.codeOrigin, deps.readEnvOrigin()),
+    configuredPublicOrigin: () => {
+      const value = deps.readEnvOrigin();
+      if (typeof value !== "string") return null;
+      const trimmed = value.trim();
+      return trimmed ? trimmed : null;
+    },
+    publicOriginFromEnv: () => originIsFromEnvironment(deps.codeOrigin, deps.readEnvOrigin()),
+  };
+}