@bygghammar/cms-platform 0.18.0 → 0.19.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.18.0",
+  "version": "0.19.1",
   "description": "Shared CMS platform: blocks, block types, i18n core, UI primitives and design-token contract used by every Bygghammar/Voyara site.",
   "type": "module",
   "sideEffects": false,
@@ -103,7 +103,11 @@
     "./backoffice/MediaLibraryView": "./src/backoffice/MediaLibraryView.tsx",
     "./backoffice/FormEditorView": "./src/backoffice/FormEditorView.tsx",
     "./backoffice/FormsIndexView": "./src/backoffice/FormsIndexView.tsx",
-    "./backoffice/RedirectsView": "./src/backoffice/RedirectsView.tsx"
+    "./backoffice/RedirectsView": "./src/backoffice/RedirectsView.tsx",
+    "./server/guards": "./src/server/guards.ts",
+    "./server/redirects-core": "./src/server/redirects-core.ts",
+    "./server/page-seo-core": "./src/server/page-seo-core.ts",
+    "./server/media-cleanup-core": "./src/server/media-cleanup-core.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/server/guards.ts

@@ -0,0 +1,43 @@
+/**
+ * Host-agnostic authorization guards for platform server functions.
+ *
+ * The host passes the request context of its own auth middleware: an
+ * authenticated Supabase-shaped client plus the signed-in user id. Every check
+ * runs as that user, so row-level security still applies — these helpers never
+ * receive or use privileged credentials.
+ */
+
+/** Minimal shape of an authenticated request context a host must provide. */
+export type PlatformAuthContext = {
+  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+  supabase: { rpc: (fn: any, args: any) => Promise<{ data: any; error: any }> };
+  userId: string;
+  claims?: { email?: string | null } | null;
+};
+
+/** Email of the acting user, when the host's claims carry one. */
+export function actorEmail(context: PlatformAuthContext): string | null {
+  return context.claims?.email ?? null;
+}
+
+/** Throws unless the caller passes the host's `is_staff` check. */
+export async function assertStaff(context: PlatformAuthContext): Promise<void> {
+  const { data, error } = await context.supabase.rpc("is_staff", { _user_id: context.userId });
+  if (error) throw new Error(error.message);
+  if (!data) throw new Error("Forbidden");
+}
+
+/** Throws unless the caller holds `_role` according to the host's `has_role`. */
+export async function assertRole(context: PlatformAuthContext, role: string): Promise<void> {
+  const { data, error } = await context.supabase.rpc("has_role", {
+    _user_id: context.userId,
+    _role: role,
+  });
+  if (error) throw new Error(error.message);
+  if (!data) throw new Error(`Forbidden — ${role} only`);
+}
+
+/** Convenience wrapper for the superadmin-only maintenance tools. */
+export function assertSuperadmin(context: PlatformAuthContext): Promise<void> {
+  return assertRole(context, "superadmin");
+}

package/src/server/media-cleanup-core.ts

@@ -0,0 +1,222 @@
+/**
+ * Host-agnostic media library maintenance: find byte-identical duplicates and
+ * legacy timestamp-prefixed filenames, then repair them safely.
+ *
+ * Nothing is ever hard-deleted: duplicates are moved into the media bin after
+ * every CMS reference has been repointed at the keeper, so a wrong merge stays
+ * fully recoverable. The host injects storage access, reference rewriting and
+ * the database side effects; this module owns the planning and the sequencing.
+ */
+import { cleanFileName, splitExt, uniqueFileName } from "../media/filename";
+
+export type DuplicateGroup = { hash: string; size: number; keep: string; remove: string[] };
+export type RenamePlan = { from: string; to: string };
+
+export type MediaCleanupPlan = {
+  duplicates: DuplicateGroup[];
+  renames: RenamePlan[];
+  duplicateBytes: number;
+  scanned: number;
+};
+
+export type MediaCleanupResult = {
+  merged: number;
+  renamed: number;
+  rewritten: number;
+  freedBytes: number;
+  errors: string[];
+};
+
+/** Storage surface the cleanup needs — satisfied by `getMediaStorage()`. */
+export type CleanupStorage = {
+  list: () => Promise<{ name: string; size: number }[]>;
+  download: (path: string) => Promise<Uint8Array>;
+  move: (from: string, to: string) => Promise<unknown>;
+  publicUrl: (path: string) => string;
+};
+
+/** Database side effects the host performs with its own privileged client. */
+export type CleanupHost = {
+  storage: CleanupStorage;
+  /** Repoint stored references from any of `oldUrls` to `newUrl`; returns hits. */
+  rewriteReferences: (oldUrls: string[], newUrl: string) => Promise<number>;
+  /** Record a merged duplicate in the recoverable bin under `trashPrefix`. */
+  trashDuplicate: (input: {
+    trashId: string;
+    path: string;
+    trashPrefix: string;
+    size: number;
+    mergedInto: string;
+  }) => Promise<void>;
+  /** Move metadata/focal rows keyed by storage path onto the new path. */
+  movePathRows: (from: string, to: string) => Promise<void>;
+  /** Best-effort audit entry for the whole run. */
+  logCleanup?: (result: MediaCleanupResult) => Promise<void>;
+};
+
+const TIMESTAMP_PREFIX = /^\d{10,16}-(?=.)/;
+
+const dirOf = (path: string) => {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? "" : path.slice(0, i);
+};
+
+const baseOf = (path: string) => {
+  const i = path.lastIndexOf("/");
+  return i === -1 ? path : path.slice(i + 1);
+};
+
+/** Prefer the cleanest, shortest, oldest name as the surviving file. */
+export function pickKeeper(paths: string[]): string {
+  return [...paths].sort((a, b) => {
+    const ta = TIMESTAMP_PREFIX.test(baseOf(a)) ? 1 : 0;
+    const tb = TIMESTAMP_PREFIX.test(baseOf(b)) ? 1 : 0;
+    if (ta !== tb) return ta - tb;
+    if (a.length !== b.length) return a.length - b.length;
+    return a < b ? -1 : 1;
+  })[0];
+}
+
+async function sha256(bytes: Uint8Array) {
+  const digest = await crypto.subtle.digest("SHA-256", bytes.slice().buffer as ArrayBuffer);
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+/** Never touch the bin. */
+const isManaged = (path: string) => !path.startsWith("trash/");
+
+/** Plan the renames of legacy timestamp-prefixed names among surviving files. */
+export function planRenames(survivors: Iterable<string>): RenamePlan[] {
+  const takenByDir = new Map<string, Set<string>>();
+  for (const path of survivors) {
+    const set = takenByDir.get(dirOf(path)) ?? new Set<string>();
+    set.add(baseOf(path));
+    takenByDir.set(dirOf(path), set);
+  }
+
+  const renames: RenamePlan[] = [];
+  for (const path of Array.from(survivors).sort()) {
+    const base = baseOf(path);
+    if (!TIMESTAMP_PREFIX.test(base)) continue;
+    const dir = dirOf(path);
+    const taken = takenByDir.get(dir)!;
+    const { ext } = splitExt(base);
+    const cleaned = cleanFileName(base, "file");
+    const candidate = uniqueFileName(cleaned || `file${ext}`, taken);
+    if (candidate === base) continue;
+    taken.delete(base);
+    taken.add(candidate);
+    renames.push({ from: path, to: dir ? `${dir}/${candidate}` : candidate });
+  }
+  return renames;
+}
+
+export async function planMediaCleanup(storage: CleanupStorage): Promise<MediaCleanupPlan> {
+  const files = (await storage.list()).filter((f) => isManaged(f.name));
+
+  // Hash only files that share a byte size with at least one other file.
+  const bySize = new Map<number, string[]>();
+  for (const f of files) {
+    const list = bySize.get(f.size) ?? [];
+    list.push(f.name);
+    bySize.set(f.size, list);
+  }
+
+  const duplicates: DuplicateGroup[] = [];
+  let duplicateBytes = 0;
+  for (const [size, names] of bySize) {
+    if (names.length < 2 || size === 0) continue;
+    const byHash = new Map<string, string[]>();
+    for (const name of names) {
+      try {
+        const hash = await sha256(await storage.download(name));
+        const list = byHash.get(hash) ?? [];
+        list.push(name);
+        byHash.set(hash, list);
+      } catch {
+        /* unreadable object — leave it alone */
+      }
+    }
+    for (const [hash, group] of byHash) {
+      if (group.length < 2) continue;
+      const keep = pickKeeper(group);
+      const remove = group.filter((p) => p !== keep);
+      duplicates.push({ hash, size, keep, remove });
+      duplicateBytes += size * remove.length;
+    }
+  }
+
+  const survivors = new Set(files.map((f) => f.name));
+  for (const group of duplicates) for (const p of group.remove) survivors.delete(p);
+
+  return { duplicates, renames: planRenames(survivors), duplicateBytes, scanned: files.length };
+}
+
+export async function applyMediaCleanupPlan(
+  plan: MediaCleanupPlan,
+  options: { duplicates: boolean; renames: boolean },
+  host: CleanupHost,
+): Promise<MediaCleanupResult> {
+  const { storage } = host;
+  const result: MediaCleanupResult = {
+    merged: 0,
+    renamed: 0,
+    rewritten: 0,
+    freedBytes: 0,
+    errors: [],
+  };
+
+  if (options.duplicates) {
+    for (const group of plan.duplicates) {
+      const keeperUrl = storage.publicUrl(group.keep);
+      for (const dup of group.remove) {
+        try {
+          result.rewritten += await host.rewriteReferences(
+            [storage.publicUrl(dup), dup],
+            keeperUrl,
+          );
+          const trashId = crypto.randomUUID();
+          const trashPrefix = `trash/${trashId}`;
+          await storage.move(dup, `${trashPrefix}/${dup}`);
+          await host.trashDuplicate({
+            trashId,
+            path: dup,
+            trashPrefix,
+            size: group.size,
+            mergedInto: group.keep,
+          });
+          result.merged += 1;
+          result.freedBytes += group.size;
+        } catch (error) {
+          result.errors.push(`${dup}: ${error instanceof Error ? error.message : "failed"}`);
+        }
+      }
+    }
+  }
+
+  if (options.renames) {
+    for (const rename of plan.renames) {
+      try {
+        await storage.move(rename.from, rename.to);
+        result.rewritten += await host.rewriteReferences(
+          [storage.publicUrl(rename.from), rename.from],
+          storage.publicUrl(rename.to),
+        );
+        await host.movePathRows(rename.from, rename.to);
+        result.renamed += 1;
+      } catch (error) {
+        result.errors.push(`${rename.from}: ${error instanceof Error ? error.message : "failed"}`);
+      }
+    }
+  }
+
+  try {
+    await host.logCleanup?.(result);
+  } catch {
+    /* audit is best-effort */
+  }
+
+  return result;
+}

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

@@ -0,0 +1,66 @@
+/**
+ * Host-agnostic page SEO logic: slug conflict detection and the automatic
+ * 301 redirects created when a page's slug changes.
+ */
+import { normalizePath } from "./redirects-core";
+import type { PageSlugRegistry } from "./redirects-core";
+
+export type SlugConflict = { locale: string; pageKey: string };
+
+/**
+ * No two pages may resolve to the same URL in the same locale.
+ * `existing` is the stored override map, `pending` the edit being saved.
+ */
+export function detectSlugConflictsCore(input: {
+  pages: PageSlugRegistry;
+  locales: readonly string[];
+  existing: Record<string, Record<string, string>>;
+  pageKey: string;
+  slugs: Record<string, string>;
+}): SlugConflict[] {
+  const pendingByKey = new Map<string, Record<string, string>>(Object.entries(input.existing));
+  pendingByKey.set(input.pageKey, input.slugs);
+
+  const conflicts: SlugConflict[] = [];
+  for (const locale of input.locales) {
+    const seen = new Map<string, string>();
+    for (const key of Object.keys(input.pages)) {
+      const base = input.pages[key].slug[locale];
+      const override = pendingByKey.get(key)?.[locale];
+      const effective = override ?? base;
+      if (effective === undefined) continue;
+      const existing = seen.get(effective);
+      if (existing && existing !== key) conflicts.push({ locale, pageKey: key });
+      else seen.set(effective, key);
+    }
+  }
+  return conflicts;
+}
+
+export type SlugRedirectRow = {
+  from_path: string;
+  to_path: string;
+  status: number;
+  created_by: string;
+};
+
+/** Redirect rows needed so old URLs keep working after a slug change. */
+export function slugRedirectRows(input: {
+  locales: readonly string[];
+  previousSlugs: Record<string, string> | null;
+  registrySlugs: Record<string, string | undefined> | undefined;
+  nextSlugs: Record<string, string>;
+  userId: string;
+}): SlugRedirectRow[] {
+  const rows: SlugRedirectRow[] = [];
+  for (const locale of input.locales) {
+    const before = input.previousSlugs?.[locale] ?? input.registrySlugs?.[locale];
+    const after = input.nextSlugs[locale];
+    if (before === undefined || after === undefined || before === after) continue;
+    const fromPath = before === "" ? "/" : normalizePath(`/${before}`);
+    const toPath = after === "" ? "/" : normalizePath(`/${after}`);
+    if (fromPath === toPath) continue;
+    rows.push({ from_path: fromPath, to_path: toPath, status: 301, created_by: input.userId });
+  }
+  return rows;
+}

package/src/server/redirects-core.ts

@@ -0,0 +1,131 @@
+/**
+ * Host-agnostic redirect logic.
+ *
+ * The host owns the server-function wrappers, validation and the client; this
+ * module owns path normalization, the CRUD queries and public path resolution
+ * so every site behaves identically.
+ */
+
+/** Structural subset of a Supabase-shaped client used by these cores. */
+export type RedirectClient = {
+  from: (table: string) => any; // eslint-disable-line @typescript-eslint/no-explicit-any
+};
+
+export type RedirectRow = {
+  id: string;
+  from_path: string;
+  to_path: string;
+  status: number;
+  created_at: string;
+};
+
+export type PathResolution =
+  | { kind: "page"; pageKey: string }
+  | { kind: "redirect"; to: string; status: number }
+  | { kind: "notfound" };
+
+/** Normalize any incoming path to `/` or `/segment/segment`. */
+export function normalizePath(input: string): string {
+  const raw = (input || "/").split("?")[0].split("#")[0];
+  const trimmed = raw.replace(/\/+$/, "");
+  if (!trimmed) return "/";
+  return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+
+/** Normalize a redirect target, leaving absolute URLs untouched. */
+export function normalizeTarget(input: string): string {
+  return /^https?:\/\//i.test(input) ? input : normalizePath(input);
+}
+
+export async function listRedirectsCore(client: RedirectClient): Promise<RedirectRow[]> {
+  const { data, error } = await client
+    .from("redirects")
+    .select("id, from_path, to_path, status, created_at")
+    .order("created_at", { ascending: false });
+  if (error) throw new Error(error.message);
+  return (data ?? []) as RedirectRow[];
+}
+
+export async function saveRedirectCore(
+  client: RedirectClient,
+  input: { id?: string; from_path: string; to_path: string; status: number },
+  userId: string,
+): Promise<{ ok: true }> {
+  const row = {
+    from_path: normalizePath(input.from_path),
+    to_path: normalizeTarget(input.to_path),
+    status: input.status,
+  };
+  if (row.from_path === row.to_path) throw new Error("Source and target are identical");
+  const { error } = input.id
+    ? await client.from("redirects").update(row).eq("id", input.id)
+    : await client.from("redirects").insert({ ...row, created_by: userId });
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}
+
+export async function deleteRedirectCore(
+  client: RedirectClient,
+  id: string,
+): Promise<{ ok: true }> {
+  const { error } = await client.from("redirects").delete().eq("id", id);
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}
+
+/** Slug map of a page in the host's static page registry. */
+export type PageSlugRegistry = Record<string, { slug: Record<string, string | undefined> }>;
+
+/**
+ * Resolve a URL path to a CMS page key, a redirect, or nothing.
+ * Slug overrides from `page_seo` win over the static registry; builder-created
+ * pages resolve by bare key through the `lookupPageByKey` callback.
+ */
+export async function resolvePathCore(
+  path: string,
+  deps: {
+    client: RedirectClient;
+    pages: PageSlugRegistry;
+    locales: readonly string[];
+    lookupPageByKey: (key: string) => Promise<string | null>;
+  },
+): Promise<PathResolution> {
+  const target = normalizePath(path);
+  const bySlug = new Map<string, string>();
+  const put = (slug: string | undefined, key: string) => {
+    if (slug === undefined || slug === null) return;
+    const p = slug === "" ? "/" : `/${slug.replace(/^\/+|\/+$/g, "")}`;
+    if (!bySlug.has(p)) bySlug.set(p, key);
+  };
+
+  const { data: seoRows } = await deps.client.from("page_seo").select("page_key, slugs");
+  const overrides = new Map<string, Record<string, string>>();
+  for (const row of (seoRows ?? []) as { page_key: string; slugs: unknown }[]) {
+    overrides.set(row.page_key, (row.slugs as Record<string, string>) ?? {});
+  }
+  for (const [key, slugs] of overrides) {
+    for (const locale of deps.locales) put(slugs[locale], key);
+  }
+  for (const key of Object.keys(deps.pages)) {
+    if (overrides.has(key)) continue;
+    for (const locale of deps.locales) put(deps.pages[key].slug[locale], key);
+  }
+
+  let pageKey = bySlug.get(target);
+  if (!pageKey) {
+    const candidate = target.replace(/^\//, "");
+    if (/^[a-z0-9_-]+$/.test(candidate)) {
+      pageKey = (await deps.lookupPageByKey(candidate)) ?? undefined;
+    }
+  }
+  if (pageKey) return { kind: "page", pageKey };
+
+  const { data: hit } = await deps.client
+    .from("redirects")
+    .select("to_path, status")
+    .eq("from_path", target)
+    .maybeSingle();
+  if (hit) return { kind: "redirect", to: hit.to_path, status: hit.status ?? 301 };
+
+  return { kind: "notfound" };
+}