@bygghammar/cms-platform 0.46.1 → 0.47.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 0.47.0
+
+- Media server logic is package-owned: new `server/media-focus-core` (focus-point map, desktop/mobile upsert, clear), `server/media-meta-core` (localized alt/title/description/credit read and write) and `server/media-replace-core` (width-matched "replace everywhere" with audit trail).
+- New `server/media-cleanup-host`: `createSupabaseCleanupHost()` assembles the bin rows, `media_meta`/`media_focus` path moves and the cleanup audit entry, so a site only supplies its privileged client, storage and reference rewriter.
+
 ## 0.46.1
 
 - Page builder host contract: `renderEditor` now also receives `initialBlocks` (the server baseline) alongside the live canvas.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.46.1",
+  "version": "0.47.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": false,
@@ -166,7 +166,11 @@
     "./backoffice/ResetPasswordView": "./src/backoffice/ResetPasswordView.tsx",
     "./backoffice/routes/pages": "./src/backoffice/routes/pages.tsx",
     "./config/define-site": "./src/config/define-site.ts",
-    "./server/schema-drift": "./src/server/schema-drift.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",
+    "./server/media-replace-core": "./src/server/media-replace-core.ts",
+    "./server/media-cleanup-host": "./src/server/media-cleanup-host.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

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

@@ -0,0 +1,79 @@
+/**
+ * Supabase-backed `CleanupHost` for the media cleanup core.
+ *
+ * Every site stores media bookkeeping in the same three tables (`media_trash`,
+ * `media_meta`, `media_focus`) and the same `audit_logs` table, so the database
+ * side effects the cleanup core needs are platform logic, not site logic. A host
+ * supplies its privileged client, its storage provider and its reference
+ * rewriter; this factory assembles the rest.
+ */
+import { actorEmail, type PlatformAuthContext } from "./guards";
+import type { CleanupHost, CleanupStorage, MediaCleanupResult } from "./media-cleanup-core";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const PATH_TABLES = ["media_meta", "media_focus"] as const;
+
+export type CleanupHostDeps = {
+  context: PlatformAuthContext;
+  /** Privileged client used for the bin rows, path moves and the audit entry. */
+  admin: any;
+  /** Storage bound to the privileged client (usually `getMediaStorage(admin)`). */
+  storage: CleanupStorage;
+  /** Repoint stored references from any of `oldUrls` to `newUrl`; returns hits. */
+  rewriteReferences: (oldUrls: string[], newUrl: string) => Promise<number>;
+};
+
+export function createSupabaseCleanupHost(deps: CleanupHostDeps): CleanupHost {
+  const { admin, context } = deps;
+
+  return {
+    storage: deps.storage,
+    rewriteReferences: deps.rewriteReferences,
+
+    trashDuplicate: async ({ trashId, path, trashPrefix, size, mergedInto }) => {
+      await admin.from("media_trash").insert({
+        id: trashId,
+        original_path: path,
+        paths: [path],
+        trash_prefix: trashPrefix,
+        size_bytes: size,
+        content_type: null,
+        deleted_by: context.userId,
+        deleted_by_email: actorEmail(context),
+        usage_snapshot: { mergedInto },
+      });
+      for (const table of PATH_TABLES) {
+        await admin.from(table).delete().eq("path", path);
+      }
+    },
+
+    movePathRows: async (from: string, to: string) => {
+      for (const table of PATH_TABLES) {
+        // A row already sitting on the destination path wins; drop the stale one
+        // instead of violating the unique path constraint.
+        const { data: existing } = await admin
+          .from(table)
+          .select("path")
+          .eq("path", to)
+          .maybeSingle();
+        if (existing) {
+          await admin.from(table).delete().eq("path", from);
+          continue;
+        }
+        await admin.from(table).update({ path: to }).eq("path", from);
+      }
+    },
+
+    logCleanup: async (result: MediaCleanupResult) => {
+      await admin.from("audit_logs").insert({
+        actor_id: context.userId,
+        actor_email: actorEmail(context),
+        action: "media.cleanup",
+        entity: "media",
+        entity_id: "bulk",
+        meta: result,
+      });
+    },
+  };
+}

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

@@ -0,0 +1,136 @@
+/**
+ * Host-agnostic focus-point (focal crop) server logic.
+ *
+ * Owns the whole `media_focus` lifecycle: the public read of every stored
+ * point, the desktop/mobile upsert and the clear. Hosts supply a privileged
+ * client for the public read (the table is staff-only through row-level
+ * security, but the coordinates themselves are needed to render the site) and
+ * their authenticated request context for the writes, so RLS applies as the
+ * signed-in user.
+ */
+import { assertStaff, type PlatformAuthContext } from "./guards";
+import { clampFocal, focusKey, type FocusDevice, type FocusMap } from "../media/focus";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** Privileged-client factory the public read needs. */
+export type FocusAdmin = () => Promise<any>;
+
+/** Authenticated request context the writes run under. */
+export type FocusContext = PlatformAuthContext & { supabase: any };
+
+export type SetFocusInput = { src: string; x: number; y: number; device?: FocusDevice };
+export type ClearFocusInput = { src: string; device?: FocusDevice };
+
+export type FocusWriteResult = {
+  ok: true;
+  path?: string;
+  device?: FocusDevice;
+  x?: number;
+  y?: number;
+};
+
+/**
+ * Every stored focus point, keyed by canonical media path. Returns an empty map
+ * rather than throwing so a failed read never breaks page rendering.
+ */
+export async function getMediaFocusMapCore(admin: FocusAdmin): Promise<FocusMap> {
+  const db = await admin();
+  const { data, error } = await db
+    .from("media_focus")
+    .select("path, focal_x, focal_y, mobile_x, mobile_y");
+  if (error) return {};
+
+  const map: FocusMap = {};
+  for (const row of (data ?? []) as {
+    path: string;
+    focal_x: number;
+    focal_y: number;
+    mobile_x: number | null;
+    mobile_y: number | null;
+  }[]) {
+    map[row.path] = {
+      x: row.focal_x,
+      y: row.focal_y,
+      mobile:
+        row.mobile_x !== null && row.mobile_y !== null
+          ? { x: row.mobile_x, y: row.mobile_y }
+          : null,
+    };
+  }
+  return map;
+}
+
+/**
+ * Store a focus point. A mobile point is an override: the existing desktop
+ * coordinates are preserved (defaulting to dead centre) so switching device
+ * never silently recentres the other breakpoint.
+ */
+export async function setMediaFocusCore(
+  context: FocusContext,
+  data: SetFocusInput,
+): Promise<FocusWriteResult> {
+  await assertStaff(context);
+
+  const path = focusKey(data.src);
+  if (!path) throw new Error("Missing image path");
+  const point = clampFocal({ x: data.x, y: data.y });
+  const device: FocusDevice = data.device === "mobile" ? "mobile" : "desktop";
+
+  if (device === "mobile") {
+    const { data: existing } = await context.supabase
+      .from("media_focus")
+      .select("focal_x, focal_y")
+      .eq("path", path)
+      .maybeSingle();
+    const { error } = await context.supabase.from("media_focus").upsert(
+      {
+        path,
+        focal_x: existing?.focal_x ?? 50,
+        focal_y: existing?.focal_y ?? 50,
+        mobile_x: point.x,
+        mobile_y: point.y,
+        updated_by: context.userId,
+      },
+      { onConflict: "path" },
+    );
+    if (error) throw new Error(error.message);
+    return { ok: true, path, device, ...point };
+  }
+
+  const { error } = await context.supabase
+    .from("media_focus")
+    .upsert(
+      { path, focal_x: point.x, focal_y: point.y, updated_by: context.userId },
+      { onConflict: "path" },
+    );
+  if (error) throw new Error(error.message);
+  return { ok: true, path, device, ...point };
+}
+
+/**
+ * Drop a focus point. Clearing mobile only nulls the override; clearing desktop
+ * removes the row so the image falls back to a centred crop.
+ */
+export async function clearMediaFocusCore(
+  context: FocusContext,
+  data: ClearFocusInput,
+): Promise<FocusWriteResult> {
+  await assertStaff(context);
+
+  const path = focusKey(data.src);
+  if (!path) return { ok: true };
+
+  if (data.device === "mobile") {
+    const { error } = await context.supabase
+      .from("media_focus")
+      .update({ mobile_x: null, mobile_y: null, updated_by: context.userId })
+      .eq("path", path);
+    if (error) throw new Error(error.message);
+    return { ok: true };
+  }
+
+  const { error } = await context.supabase.from("media_focus").delete().eq("path", path);
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}

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

@@ -0,0 +1,95 @@
+/**
+ * Host-agnostic media metadata server logic (alt / title / description /
+ * credit).
+ *
+ * Alt text, title and description are localized maps so every language carries
+ * its own copy; metadata is keyed by the same canonical, variant-collapsed path
+ * as focus points. The public read uses a privileged client because the table is
+ * staff-only through row-level security while the text itself is rendered on the
+ * public site; writes run under the host's authenticated context.
+ */
+import { assertStaff, type PlatformAuthContext } from "./guards";
+import {
+  cleanLocalized,
+  metaKey,
+  type LocalizedText,
+  type MediaMetaMap,
+} from "../media/media-meta";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export type MediaMetaAdmin = () => Promise<any>;
+export type MediaMetaContext = PlatformAuthContext & { supabase: any };
+
+export type SaveMediaMetaInput = {
+  src: string;
+  alt?: LocalizedText;
+  title?: LocalizedText;
+  description?: LocalizedText;
+  credit?: string;
+};
+
+/** All stored metadata, keyed by canonical path. Never throws. */
+export async function getMediaMetaMapCore(admin: MediaMetaAdmin): Promise<MediaMetaMap> {
+  const db = await admin();
+  const { data, error } = await db
+    .from("media_meta")
+    .select("path, alt, title, description, credit");
+  if (error) return {};
+
+  const map: MediaMetaMap = {};
+  for (const row of (data ?? []) as {
+    path: string;
+    alt: LocalizedText | null;
+    title: LocalizedText | null;
+    description: LocalizedText | null;
+    credit: string | null;
+  }[]) {
+    map[row.path] = {
+      alt: row.alt ?? {},
+      title: row.title ?? {},
+      description: row.description ?? {},
+      credit: row.credit ?? "",
+    };
+  }
+  return map;
+}
+
+/** Upsert metadata for one asset; empty locales are stripped before storing. */
+export async function setMediaMetaCore(
+  context: MediaMetaContext,
+  data: SaveMediaMetaInput,
+): Promise<{ ok: true; path: string }> {
+  await assertStaff(context);
+
+  const path = metaKey(data.src);
+  if (!path) throw new Error("Missing image path");
+
+  const { error } = await context.supabase.from("media_meta").upsert(
+    {
+      path,
+      alt: cleanLocalized(data.alt),
+      title: cleanLocalized(data.title),
+      description: cleanLocalized(data.description),
+      credit: (data.credit ?? "").trim(),
+      updated_by: context.userId,
+    },
+    { onConflict: "path" },
+  );
+  if (error) throw new Error(error.message);
+  return { ok: true, path };
+}
+
+/** Remove all metadata for one asset. */
+export async function clearMediaMetaCore(
+  context: MediaMetaContext,
+  data: { src: string },
+): Promise<{ ok: true }> {
+  await assertStaff(context);
+
+  const path = metaKey(data.src);
+  if (!path) return { ok: true };
+  const { error } = await context.supabase.from("media_meta").delete().eq("path", path);
+  if (error) throw new Error(error.message);
+  return { ok: true };
+}

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

@@ -0,0 +1,102 @@
+/**
+ * Host-agnostic "replace this file everywhere" logic.
+ *
+ * Swaps one library asset for another across every stored CMS reference.
+ * Responsive variants are matched width-for-width so srcSets stay consistent;
+ * anything without a matching width falls back to the new primary file.
+ *
+ * Nothing is deleted — the old asset stays in the library, so a wrong replace is
+ * reversed by replacing back.
+ */
+import { assertStaff, actorEmail, type PlatformAuthContext } from "./guards";
+import { RESPONSIVE_WIDTHS, variantSiblings } from "../media/srcset";
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const VARIANT_RE = /-(480|768|1200|1920|2560)\.webp$/i;
+
+function variantBase(path: string): string | null {
+  const m = path.match(VARIANT_RE);
+  return m ? path.slice(0, path.length - m[0].length) : null;
+}
+
+/** Every storage path belonging to one asset (primary + responsive siblings). */
+function family(path: string): string[] {
+  return [path, ...variantSiblings(path)];
+}
+
+/** Storage surface the replace needs — satisfied by `getMediaStorage()`. */
+export type ReplaceStorage = {
+  list: () => Promise<{ name: string }[]>;
+  publicUrl: (path: string) => string;
+};
+
+export type ReplaceDeps = {
+  context: PlatformAuthContext & { supabase: any };
+  /** Privileged client used for the reference rewrite and the audit row. */
+  admin: () => Promise<any>;
+  /** Storage bound to the privileged client. */
+  storage: (admin: any) => ReplaceStorage;
+  /** Repoint stored references from any of `oldUrls` to `newUrl`; returns hits. */
+  rewriteReferences: (admin: any, oldUrls: string[], newUrl: string) => Promise<number>;
+};
+
+export type ReplaceResult = { rewritten: number; widths: number };
+
+export async function replaceMediaEverywhereCore(
+  deps: ReplaceDeps,
+  data: { fromPath: string; toPath: string },
+): Promise<ReplaceResult> {
+  await assertStaff(deps.context);
+  if (!data.fromPath || !data.toPath) throw new Error("Both files are required");
+  if (data.fromPath === data.toPath) throw new Error("Pick two different files");
+
+  const admin = await deps.admin();
+  const storage = deps.storage(admin);
+
+  const existing = new Set((await storage.list()).map((f) => f.name));
+  if (!existing.has(data.fromPath)) throw new Error("Source file not found");
+  if (!existing.has(data.toPath)) throw new Error("Replacement file not found");
+
+  const newBase = variantBase(data.toPath);
+  const newPrimaryUrl = storage.publicUrl(data.toPath);
+
+  // Most specific first: width-matched variants, then the primary path.
+  const pairs: { oldPath: string; newUrl: string }[] = [];
+  for (const oldPath of family(data.fromPath)) {
+    if (!existing.has(oldPath) && oldPath !== data.fromPath) continue;
+    const width = oldPath.match(VARIANT_RE)?.[1];
+    let target = newPrimaryUrl;
+    if (width && newBase) {
+      const candidate = `${newBase}-${width}.webp`;
+      if (existing.has(candidate)) target = storage.publicUrl(candidate);
+    }
+    pairs.push({ oldPath, newUrl: target });
+  }
+  pairs.sort((a, b) => b.oldPath.length - a.oldPath.length);
+
+  let rewritten = 0;
+  for (const pair of pairs) {
+    const url = storage.publicUrl(pair.oldPath);
+    if (!url || url === pair.newUrl) continue;
+    const candidates = Array.from(
+      new Set([url, encodeURI(url), decodeURI(url), `/${pair.oldPath}`]),
+    );
+    rewritten += await deps.rewriteReferences(admin, candidates, pair.newUrl);
+  }
+
+  try {
+    await admin.from("audit_logs").insert({
+      actor_id: deps.context.userId,
+      actor_email: actorEmail(deps.context),
+      action: "media.replace_everywhere",
+      entity: "media",
+      entity_id: data.fromPath,
+      meta: { to: data.toPath, rewritten },
+    });
+  } catch (e) {
+    console.warn("audit failed", e);
+  }
+
+  return { rewritten, widths: RESPONSIVE_WIDTHS.length };
+}