@bygghammar/cms-platform 0.33.0 → 0.34.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.34.0
+
+- Added `server/content-sections-core` — public reads and staff-only upserts of
+  site-wide content records, with manual-edit stamping.
+- Added `server/translate-db-core` — host-agnostic auto-translation sweep for
+  CMS localized JSONB fields, with brand prompt details and table specs supplied
+  by the host.
+
+## 0.33.0
+
+- Added `server/pages-core` — host-agnostic page-builder logic: pages, versions,
+  publications and scheduling, the page trash bin, global blocks/sections, the
+  global-block usage scan and the block-type reference-image scan.
+- Added `server/resolve-globals` — recursive resolution of global block
+  references, usable with either an authenticated or a privileged client.
+
+
+
 ## 0.31.0
 
 - Added `backoffice/SharedContentListView` — the shared-content library screen

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bygghammar/cms-platform",
-  "version": "0.33.0",
+  "version": "0.34.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,
@@ -143,7 +143,9 @@
     "./server/media-library-core": "./src/server/media-library-core.ts",
     "./server/admin-core": "./src/server/admin-core.ts",
     "./server/pages-core": "./src/server/pages-core.ts",
-    "./server/resolve-globals": "./src/server/resolve-globals.ts"
+    "./server/resolve-globals": "./src/server/resolve-globals.ts",
+    "./server/content-sections-core": "./src/server/content-sections-core.ts",
+    "./server/translate-db-core": "./src/server/translate-db-core.ts"
   },
   "dependencies": {
     "fflate": "^0.8.3"

package/src/server/content-sections-core.ts

@@ -0,0 +1,68 @@
+/**
+ * Host-agnostic logic for site-wide content records (`content_sections`).
+ *
+ * The host owns the server-function wrappers, input validation and the clients;
+ * this module owns the queries and the manual-edit stamping so every site keeps
+ * identical behaviour: reads are public, writes are staff-only and manual
+ * translations are never clobbered.
+ */
+
+import type { Json } from "../i18n/json";
+import { stampManualEdits } from "../i18n/translation-meta";
+import { assertStaff, type PlatformAuthContext } from "./guards";
+
+/** Structural subset of a Supabase-shaped client used by this core. */
+export type ContentClient = {
+  from: (table: string) => any; // eslint-disable-line @typescript-eslint/no-explicit-any
+};
+
+export type ContentOverrides = Record<string, Json>;
+
+/**
+ * Public read of every stored content record, keyed by record key.
+ *
+ * Never throws: a backend hiccup degrades to "no overrides" so the site still
+ * renders its in-code defaults.
+ */
+export async function getContentOverridesCore(client: ContentClient): Promise<ContentOverrides> {
+  const { data, error } = await client.from("content_sections").select("key, data");
+  if (error) {
+    console.error("[cms] getContentOverrides", error);
+    return {};
+  }
+  const out: ContentOverrides = {};
+  for (const row of (data ?? []) as { key: string; data: Json }[]) out[row.key] = row.data;
+  return out;
+}
+
+/** True when the caller passes the host's `is_staff` check. */
+export async function isStaffCore(context: PlatformAuthContext): Promise<boolean> {
+  const { data, error } = await context.supabase.rpc("is_staff", { _user_id: context.userId });
+  if (error) throw new Error(error.message);
+  return Boolean(data);
+}
+
+/**
+ * Staff-only upsert of one content record. Runs as the signed-in user, so RLS
+ * still applies. Manually edited locale values in the previous row are
+ * preserved by `stampManualEdits`.
+ */
+export async function saveContentSectionCore(
+  context: PlatformAuthContext & { supabase: ContentClient },
+  input: { key: string; data: unknown },
+): Promise<{ ok: true; key: string }> {
+  await assertStaff(context);
+
+  const { data: prevRow } = await context.supabase
+    .from("content_sections")
+    .select("data")
+    .eq("key", input.key)
+    .maybeSingle();
+  const stamped = stampManualEdits(input.data, (prevRow?.data as Json) ?? null);
+
+  const { error } = await context.supabase
+    .from("content_sections")
+    .upsert({ key: input.key, data: stamped as Json }, { onConflict: "key" });
+  if (error) throw new Error(error.message);
+  return { ok: true, key: input.key };
+}

package/src/server/translate-db-core.ts

@@ -0,0 +1,194 @@
+/**
+ * Host-agnostic auto-translation runner for CMS-backed localized JSONB fields.
+ *
+ * Rules (owned by `i18n/translation-meta`): manual translations are never
+ * overwritten, the source locale is never touched and no customer data is read.
+ * The host supplies its auth context, its brand prompt details and the tables to
+ * sweep; everything else is identical across sites.
+ */
+
+import type { Json } from "../i18n/json";
+import { collectMissing } from "../i18n/translation-meta";
+import { assertStaff, type PlatformAuthContext } from "./guards";
+
+export type TranslateMode = "missing" | "stale" | "force";
+
+/** One table to sweep: its key column plus the localized JSONB columns. */
+export type TranslateTableSpec = {
+  table: string;
+  keyCol: string;
+  jsonCols: string[];
+};
+
+/** Default sweep: content records and page SEO. */
+export const DEFAULT_TRANSLATE_TABLES: TranslateTableSpec[] = [
+  { table: "content_sections", keyCol: "key", jsonCols: ["data"] },
+  { table: "page_seo", keyCol: "page_key", jsonCols: ["slugs", "seo"] },
+];
+
+export type TranslateBrand = {
+  /** Brand name, kept unchanged by the translator. */
+  name: string;
+  /** One short sentence describing the site, for translation tone. */
+  description?: string;
+  /** Extra proper nouns that must stay untouched (places, product names). */
+  properNouns?: string[];
+  /** Human-readable source language, defaults to Swedish. */
+  sourceLanguage?: string;
+};
+
+export type TranslateOptions = {
+  target: string;
+  mode: TranslateMode;
+  brand: TranslateBrand;
+  tables?: TranslateTableSpec[];
+  /** AI gateway model id. */
+  model?: string;
+  /** Strings per request. */
+  batchSize?: number;
+  /** Gateway key; the host reads it from its own runtime env. */
+  apiKey: string;
+  /** Gateway chat-completions endpoint. */
+  endpoint?: string;
+};
+
+export type TranslateResult = {
+  ok: true;
+  translated: number;
+  updatedRows: number;
+  skippedManual: number;
+  mode: TranslateMode;
+};
+
+const DEFAULT_MODEL = "google/gemini-2.5-flash";
+const DEFAULT_BATCH = 25;
+const DEFAULT_ENDPOINT = "https://ai.gateway.lovable.dev/v1/chat/completions";
+
+function systemPrompt(brand: TranslateBrand, target: string): string {
+  const source = brand.sourceLanguage ?? "Swedish";
+  const nouns = [brand.name, ...(brand.properNouns ?? [])].join(", ");
+  return [
+    `You are a professional translator for ${brand.name}${brand.description ? ` — ${brand.description}` : ""}.`,
+    `Translate each ${source} source string to ${target === "en" ? "natural, marketing-quality English" : target}.`,
+    "Preserve line breaks, HTML tags, {placeholders}, URLs, emails, prices, currency.",
+    `Keep proper nouns unchanged: ${nouns}.`,
+    "Do not translate URL slugs or numeric-only strings — return unchanged.",
+    'Return ONLY: { "t": [ ...translations in the same order... ] }.',
+  ].join("\n");
+}
+
+/** Translate one batch of strings through the AI gateway. */
+export async function translateBatchCore(
+  texts: string[],
+  opts: Pick<TranslateOptions, "apiKey" | "brand" | "target" | "model" | "endpoint">,
+): Promise<string[]> {
+  const res = await fetch(opts.endpoint ?? DEFAULT_ENDPOINT, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", Authorization: `Bearer ${opts.apiKey}` },
+    body: JSON.stringify({
+      model: opts.model ?? DEFAULT_MODEL,
+      messages: [
+        { role: "system", content: systemPrompt(opts.brand, opts.target) },
+        { role: "user", content: JSON.stringify({ strings: texts }) },
+      ],
+      response_format: { type: "json_object" },
+    }),
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    if (res.status === 429) throw new Error("Rate limited — try again shortly.");
+    if (res.status === 402) throw new Error("AI credits exhausted.");
+    throw new Error(`AI gateway ${res.status}: ${body.slice(0, 300)}`);
+  }
+  const json = (await res.json()) as { choices?: { message?: { content?: string } }[] };
+  const content = json.choices?.[0]?.message?.content ?? "{}";
+  const parsed = JSON.parse(content) as { t?: unknown };
+  if (!Array.isArray(parsed.t) || parsed.t.length !== texts.length) {
+    throw new Error("Translation shape mismatch");
+  }
+  return parsed.t.map((v) => String(v));
+}
+
+type RowPlan = {
+  table: string;
+  keyCol: string;
+  keyVal: string | number;
+  patches: { col: string; patch: (m: Map<string, string>) => Json }[];
+};
+
+/**
+ * Staff-only: fill missing or stale translations for the target locale across
+ * every configured table. Runs as the signed-in user, so RLS applies.
+ */
+export async function translateMissingCmsCore(
+  context: PlatformAuthContext & {
+    supabase: { from: (table: string) => any }; // eslint-disable-line @typescript-eslint/no-explicit-any
+  },
+  opts: TranslateOptions,
+): Promise<TranslateResult> {
+  await assertStaff(context);
+  if (!opts.apiKey) throw new Error("AI gateway key missing");
+
+  const tables = opts.tables ?? DEFAULT_TRANSLATE_TABLES;
+  const { target, mode } = opts;
+
+  // 1) Collect every string needing translation across all rows.
+  const needSet = new Set<string>();
+  const plans: RowPlan[] = [];
+  let skippedManual = 0;
+
+  for (const spec of tables) {
+    const cols = [spec.keyCol, ...spec.jsonCols].join(", ");
+    const { data: rows, error } = (await context.supabase.from(spec.table).select(cols)) as {
+      data: Record<string, unknown>[] | null;
+      error: { message: string } | null;
+    };
+    if (error) throw new Error(`${spec.table}: ${error.message}`);
+    for (const row of rows ?? []) {
+      const plan: RowPlan = {
+        table: spec.table,
+        keyCol: spec.keyCol,
+        keyVal: row[spec.keyCol] as string | number,
+        patches: [],
+      };
+      let rowHasWork = false;
+      for (const col of spec.jsonCols) {
+        const { needs, skippedManual: sm, patch } = collectMissing(row[col], target, mode);
+        skippedManual += sm;
+        if (needs.length > 0) rowHasWork = true;
+        for (const n of needs) needSet.add(n);
+        plan.patches.push({ col, patch });
+      }
+      if (rowHasWork) plans.push(plan);
+    }
+  }
+
+  const needs = [...needSet];
+  if (needs.length === 0) {
+    return { ok: true, translated: 0, updatedRows: 0, skippedManual, mode };
+  }
+
+  // 2) Translate in batches.
+  const map = new Map<string, string>();
+  const batchSize = opts.batchSize ?? DEFAULT_BATCH;
+  for (let i = 0; i < needs.length; i += batchSize) {
+    const chunk = needs.slice(i, i + batchSize);
+    const out = await translateBatchCore(chunk, opts);
+    chunk.forEach((s, idx) => map.set(s, out[idx]));
+  }
+
+  // 3) Patch and write rows back.
+  let updatedRows = 0;
+  for (const p of plans) {
+    const update: Record<string, Json> = {};
+    for (const { col, patch } of p.patches) update[col] = patch(map);
+    const { error } = (await context.supabase
+      .from(p.table)
+      .update(update)
+      .eq(p.keyCol, p.keyVal)) as { error: { message: string } | null };
+    if (error) throw new Error(`${p.table} ${p.keyVal}: ${error.message}`);
+    updatedRows += 1;
+  }
+
+  return { ok: true, translated: map.size, updatedRows, skippedManual, mode };
+}