@bygghammar/cms-platform 0.56.0 → 0.57.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.57.0
+
+- Server-function inputs are now platform contracts: `server/schemas` ships the
+  shared zod validators for the page builder, administration, media library,
+  redirects and the page SEO editor. Sites keep declaring their own server
+  functions (the build step requires it) but stop re-writing the shapes.
+- New `server/page-seo-save-core`: slug-conflict rejection, manual-edit
+  stamping, automatic 301 redirects and the page SEO upsert now live in the
+  package. Sites supply their locales, registry slugs and client only.
+- `zod` is declared as a peer dependency.
+
 ## 0.56.0
 
 - Public site chrome is now package-owned: `site/SiteHeader` and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.56.0",
+  "version": "0.57.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": [
@@ -205,7 +205,9 @@
     "./util/use-hash-scroll": "./src/util/use-hash-scroll.ts",
     "./site/site-url": "./src/site/site-url.ts",
     "./site/SiteHeader": "./src/site/SiteHeader.tsx",
-    "./site/SiteFooter": "./src/site/SiteFooter.tsx"
+    "./site/SiteFooter": "./src/site/SiteFooter.tsx",
+    "./server/schemas": "./src/server/schemas.ts",
+    "./server/page-seo-save-core": "./src/server/page-seo-save-core.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"
@@ -232,7 +234,8 @@
     "@tiptap/extension-table": ">=3",
     "@dnd-kit/core": ">=6",
     "@dnd-kit/sortable": ">=3",
-    "@dnd-kit/utilities": ">=3"
+    "@dnd-kit/utilities": ">=3",
+    "zod": ">=3"
   },
   "peerDependenciesMeta": {
     "@supabase/supabase-js": {

package/src/server/page-seo-save-core.ts

@@ -0,0 +1,99 @@
+/**
+ * Host-agnostic page SEO write path: slug-conflict rejection, manual-edit
+ * stamping, automatic 301 redirects for changed slugs, and the upsert itself.
+ *
+ * The site owns only its page registry, its locales and its authenticated
+ * client; every rule below is shared by every site.
+ */
+import { stampManualEdits } from "../i18n/translation-meta";
+import { slugRedirectRows, type SlugConflict } from "./page-seo-core";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+type Client = {
+  from: (table: string) => any;
+};
+
+export type PageSeoWriteContext = { supabase: Client; userId: string };
+
+export type PageSeoSaveInput = {
+  pageKey: string;
+  slugs: Record<string, unknown>;
+  seo: Record<string, unknown>;
+};
+
+export type PageSeoSaveResult =
+  | { ok: true; pageKey: string }
+  | { ok: false; reason: "slug_conflict"; conflicts: SlugConflict[] };
+
+export type PageSeoSaveDeps = {
+  context: PageSeoWriteContext;
+  locales: readonly string[];
+  /** Slug map declared in the site's route registry for this page, if any. */
+  registrySlugs?: Record<string, string> | undefined;
+  /** Site-side conflict lookup (it reads the stored overrides). */
+  detectConflicts: (input: PageSeoSaveInput) => Promise<SlugConflict[]>;
+};
+
+export async function savePageSeoCore(
+  deps: PageSeoSaveDeps,
+  data: PageSeoSaveInput,
+): Promise<PageSeoSaveResult> {
+  const { context } = deps;
+
+  const conflicts = await deps.detectConflicts(data);
+  if (conflicts.length > 0) return { ok: false, reason: "slug_conflict", conflicts };
+
+  const { data: prevRow } = await context.supabase
+    .from("page_seo")
+    .select("slugs, seo")
+    .eq("page_key", data.pageKey)
+    .maybeSingle();
+
+  const stampedSlugs = stampManualEdits(data.slugs, prevRow?.slugs ?? null);
+  const stampedSeo = stampManualEdits(data.seo, prevRow?.seo ?? null);
+
+  // Any previous public URL keeps working: create 301s to the new one.
+  const rows = slugRedirectRows({
+    locales: deps.locales,
+    previousSlugs: (prevRow?.slugs as Record<string, string> | null) ?? null,
+    registrySlugs: deps.registrySlugs,
+    nextSlugs: data.slugs as Record<string, string>,
+    userId: context.userId,
+  });
+
+  if (rows.length > 0) {
+    // Retarget stale chains that pointed at the old path, then insert.
+    for (const r of rows) {
+      await context.supabase
+        .from("redirects")
+        .update({ to_path: r.to_path })
+        .eq("to_path", r.from_path);
+      await context.supabase.from("redirects").delete().eq("from_path", r.from_path);
+    }
+    const { error: redirErr } = await context.supabase.from("redirects").insert(rows);
+    if (redirErr) console.error("[cms] redirect create", redirErr);
+  }
+
+  const { error } = await context.supabase.from("page_seo").upsert(
+    {
+      page_key: data.pageKey,
+      slugs: stampedSlugs,
+      seo: stampedSeo,
+      updated_by: context.userId,
+    },
+    { onConflict: "page_key" },
+  );
+  if (error) throw new Error(error.message);
+
+  return { ok: true, pageKey: data.pageKey };
+}
+
+/** Remove a page's stored override, falling back to the code registry. */
+export async function deletePageSeoOverrideCore(
+  context: PageSeoWriteContext,
+  pageKey: string,
+): Promise<{ ok: true; pageKey: string }> {
+  const { error } = await context.supabase.from("page_seo").delete().eq("page_key", pageKey);
+  if (error) throw new Error(error.message);
+  return { ok: true, pageKey };
+}

package/src/server/schemas.ts

@@ -0,0 +1,245 @@
+/**
+ * Shared input validators for the platform's server functions.
+ *
+ * Every site declares its server functions locally (TanStack's build step must
+ * see `createServerFn` in the site's own source), but the *shapes* those
+ * functions accept are platform contracts. They live here so a validator is
+ * written, reviewed and fixed exactly once.
+ *
+ * These modules are pure zod schemas: no database access, no auth, no request
+ * state, so they are safe to import from either side of the boundary.
+ */
+import { z } from "zod";
+
+/* ------------------------------------------------------------------ shared */
+
+export const uuid = z.string().uuid();
+export const uuidInput = <K extends string>(key: K) => z.object({ [key]: uuid } as Record<K, typeof uuid>);
+
+/** Optional email that accepts an empty string and stores it as null. */
+export const nullableEmail = z
+  .string()
+  .email()
+  .nullable()
+  .optional()
+  .or(z.literal("").transform(() => null));
+
+/** CMS key: lowercase, digits, dash and underscore only. */
+export const cmsKey = z
+  .string()
+  .min(1)
+  .max(64)
+  .regex(/^[a-z0-9_-]+$/);
+
+export const listLimit = z.object({ limit: z.number().min(1).max(500).default(200) });
+
+/* --------------------------------------------------------------- page builder */
+
+/** One block instance as it travels over the wire. */
+export const blockInstanceSchema = z.object({
+  id: z.string().min(1),
+  type: z.string().min(1),
+  name: z.string().max(120).optional(),
+  props: z.record(z.string(), z.any()).optional(),
+  visible: z.boolean().optional(),
+});
+
+export const pageSchemas = {
+  key: z.object({ key: z.string() }),
+  pageId: z.object({ pageId: uuid }),
+  versionId: z.object({ versionId: uuid }),
+  sectionId: z.object({ sectionId: uuid }),
+  publicationId: z.object({ publicationId: uuid }),
+  createPage: z.object({ key: cmsKey, name: z.string().min(1).max(120) }),
+  renamePage: z.object({ pageId: uuid, name: z.string().min(1).max(120) }),
+  savePageVersion: z.object({
+    pageId: uuid,
+    blocks: z.array(blockInstanceSchema),
+    publish: z.boolean().optional(),
+    note: z.string().max(500).optional(),
+  }),
+  createGlobalSection: z.object({
+    key: cmsKey,
+    name: z.string().min(1).max(120),
+    blocks: z.array(blockInstanceSchema).optional(),
+    kind: z.enum(["block", "section"]).optional(),
+  }),
+  setGlobalSectionKind: z.object({ sectionId: uuid, kind: z.enum(["block", "section"]) }),
+  saveGlobalSectionVersion: z.object({
+    sectionId: uuid,
+    blocks: z.array(blockInstanceSchema),
+    note: z.string().max(500).optional(),
+  }),
+  renameGlobalSection: z.object({ sectionId: uuid, name: z.string().min(1).max(120) }),
+  schedulePageVersion: z.object({
+    versionId: uuid,
+    publishAt: z.string().datetime(),
+    unpublishAt: z.string().datetime().nullable().optional(),
+    note: z.string().max(500).optional(),
+  }),
+} as const;
+
+/* ------------------------------------------------------------- administration */
+
+/**
+ * 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[]];
+}) {
+  const role = z.enum(input.roles);
+  return {
+    role,
+    createUser: z.object({
+      email: z.string().email(),
+      password: z.string().min(8).max(128).optional(),
+      roles: z.array(role).default([]),
+    }),
+    userId: z.object({ userId: uuid }),
+    setUserPassword: z.object({ userId: uuid, password: z.string().min(8).max(128) }),
+    setUserRoles: z.object({ userId: uuid, roles: z.array(role) }),
+    email: z.object({ email: z.string().email() }),
+    listLimit,
+    emailSettings: z.object({
+      primary_from_name: z.string().max(200).nullable().optional(),
+      primary_from_email: nullableEmail,
+      backup_from_email: nullableEmail,
+      reply_to: nullableEmail,
+      admin_notify_to: z.string().max(500).nullable().optional(),
+      default_provider_id: uuid.nullable().optional(),
+      fallback_provider_id: uuid.nullable().optional(),
+    }),
+    emailProvider: z.object({
+      id: uuid.optional(),
+      name: z.string().min(1).max(120),
+      kind: z.enum(input.providerKinds),
+      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(),
+      from_email: nullableEmail,
+      reply_to: nullableEmail,
+      config: z.record(z.string(), z.unknown()).default({}),
+      secret_ref_name: z.string().max(200).nullable().optional(),
+      notes: z.string().max(2000).nullable().optional(),
+    }),
+    id: z.object({ id: uuid }),
+    sendTestEmail: z.object({ provider_id: uuid, to: z.string().email().max(320) }),
+  } as const;
+}
+
+/* --------------------------------------------------------------------- media */
+
+export const mediaSchemas = {
+  path: z.object({ path: z.string().min(1) }),
+  id: z.object({ id: uuid }),
+  uploadBundle: z.object({
+    files: z
+      .array(
+        z.object({
+          name: z.string().min(1),
+          contentType: z.string().min(1),
+          bytes: z.array(z.number().int().min(0).max(255)),
+        }),
+      )
+      .min(1)
+      .max(50),
+    upsert: z.boolean().optional(),
+  }),
+  reviewImage: z.object({
+    slug: z.string().trim().min(1).max(80),
+    variants: z
+      .array(z.object({ width: z.number().int(), data: z.string().min(16).max(4_000_000) }))
+      .length(4),
+  }),
+  prepareOverwrite: z.object({ bases: z.array(z.string().min(1)).max(500) }),
+  logOverwrite: z.object({
+    paths: z.array(z.string()).max(3000),
+    skipped: z.array(z.string()).max(500),
+    failed: z.array(z.string()).max(500),
+  }),
+} as const;
+
+/* ------------------------------------------------------------------ redirects */
+
+export const redirectSchemas = {
+  path: z.object({ path: z.string().max(512) }),
+  id: z.object({ id: uuid }),
+  save: z.object({
+    id: uuid.optional(),
+    from_path: z.string().min(1).max(512),
+    to_path: z.string().min(1).max(512),
+    status: z
+      .number()
+      .int()
+      .refine((n) => n === 301 || n === 302, "301 or 302"),
+  }),
+} as const;
+
+/* --------------------------------------------------------------------- page SEO */
+
+const localeMetaMap = z
+  .record(
+    z.string(),
+    z
+      .object({
+        origin: z.enum(["auto", "manual"]),
+        svHash: z.string().optional(),
+        updatedAt: z.string().optional(),
+      })
+      .passthrough(),
+  )
+  .optional();
+
+const localizedString = z.object({ _meta: localeMetaMap }).catchall(z.string());
+
+const localizedImage = z
+  .object({
+    src: z.string().url().or(z.string().startsWith("/")),
+    alt: localizedString,
+    srcByLocale: z.object({ _meta: localeMetaMap }).catchall(z.string()).optional(),
+    width: z.number().int().positive().optional(),
+    height: z.number().int().positive().optional(),
+  })
+  .optional();
+
+/**
+ * Page SEO editor inputs. The site supplies its own page keys and locales;
+ * 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[]];
+}) {
+  const seo = z
+    .object({
+      title: localizedString.optional(),
+      description: localizedString.optional(),
+      ogTitle: localizedString.optional(),
+      ogDescription: localizedString.optional(),
+      ogImage: localizedImage,
+      ogType: z.enum(["website", "article", "product"]).optional(),
+      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(),
+    })
+    .strict();
+
+  const slugs = z.object({ _meta: localeMetaMap }).catchall(z.string().max(120));
+
+  return {
+    seo,
+    slugs,
+    save: z.object({ pageKey: z.enum(input.pageKeys), slugs, seo }),
+    delete: z.object({ pageKey: z.enum(input.pageKeys) }),
+  } as const;
+}
+
+export type PageSeoSaveInput = {
+  pageKey: string;
+  slugs: Record<string, unknown>;
+  seo: Record<string, unknown>;
+};