@riducms/admin 0.2.2 → 0.3.0

package/src/features/versions/version-diff.ts

@@ -1,7 +1,13 @@
-import type { SchemaCollection, SchemaField } from "@riducms/protocol";
+import {
+	isRecord,
+	resolveBlockTypes,
+	type SchemaCollection,
+	type SchemaField,
+} from "@riducms/protocol";
 import type { AdminI18n } from "@riducms/translations";
-
-import type { AdminDocument, AdminVersion } from "@admin/core/api/admin-client";
+import type { AdminVersion } from "@admin/core/api/admin-client";
+import { versionDate } from "@admin/features/versions/version-history";
+import { formatDateDisplay } from "@admin/fields/scalar/date-value";
 
 export interface VersionDiffRow {
 	path: string;
@@ -9,64 +15,313 @@ export interface VersionDiffRow {
 	before: unknown;
 	after: unknown;
 	changed: boolean;
+	field?: SchemaField;
+	locale?: string;
+	children?: VersionDiffRow[];
 }
 
 export function versionDiffRows(
 	collection: SchemaCollection,
 	current: AdminVersion,
 	comparison: AdminVersion | undefined,
-	i18n: AdminI18n
+	i18n: AdminI18n,
+	locales?: readonly string[]
+): VersionDiffRow[] {
+	const rows = compareFields(
+		collection.fields,
+		comparison?.Snapshot,
+		current.Snapshot,
+		"",
+		i18n,
+		locales
+	);
+	for (const name of ["updatedAt", "createdAt", "deletedAt"] as const) {
+		if (name in current.Snapshot || (comparison && name in comparison.Snapshot))
+			rows.push({
+				path: name,
+				label: i18n.t(`versions:${name}`),
+				before: comparison?.Snapshot[name],
+				after: current.Snapshot[name],
+				changed: !sameValue(comparison?.Snapshot[name], current.Snapshot[name]),
+			});
+	}
+	rows.push({
+		path: "_status",
+		label: i18n.t("versions:status"),
+		before: comparison?.Status,
+		after: current.Status,
+		changed: comparison?.Status !== current.Status,
+	});
+	return rows;
+}
+
+function compareFields(
+	fields: readonly SchemaField[],
+	before: unknown,
+	after: unknown,
+	prefix: string,
+	i18n: AdminI18n,
+	locales?: readonly string[]
 ): VersionDiffRow[] {
-	const fields = comparisonFields(collection.fields);
-	return [
-		{
-			path: "_status",
-			label: i18n.t("versions:status"),
-			before: comparison?.Status,
-			after: current.Status,
-			changed: !sameValue(comparison?.Status, current.Status),
-		},
-		...fields.map(({ field, path }) => {
-			const before = valueAtPath(comparison?.Snapshot, path);
-			const after = valueAtPath(current.Snapshot, path);
+	const rows: VersionDiffRow[] = [];
+	for (const field of fields) {
+		if (field.type === "ui" || field.virtual || field.join || field.admin.hidden) continue;
+		const label = i18n.text(field.admin.label || field.name, field.admin.labelTranslations);
+		const path = prefix ? `${prefix}.${field.name}` : field.name;
+		const left = isRecord(before) ? before[field.name] : undefined;
+		const right = isRecord(after) ? after[field.name] : undefined;
+		const row = compareField(field, left, right, path, label, i18n, locales);
+		const section = field.admin.tab || field.admin.collapsible?.label;
+		if (section) {
+			const sectionPath = `${prefix}:section:${field.admin.tabGroup?.id ?? field.admin.collapsible?.id ?? ""}:${section}`;
+			let group = rows.find((item) => item.path === sectionPath);
+			if (!group) {
+				group = {
+					path: sectionPath,
+					label: i18n.text(
+						section,
+						field.admin.tab
+							? field.admin.tabTranslations
+							: field.admin.collapsible?.labelTranslations
+					),
+					before: undefined,
+					after: undefined,
+					changed: false,
+					children: [],
+				};
+				rows.push(group);
+			}
+			group.children!.push(row);
+			group.changed ||= row.changed;
+		} else rows.push(row);
+	}
+	return rows.map((row) => {
+		const child = row.children?.[0];
+		return !row.field && row.children?.length === 1 && child?.children && child.label === row.label
+			? child
+			: row;
+	});
+}
+
+function compareField(
+	field: SchemaField,
+	before: unknown,
+	after: unknown,
+	path: string,
+	label: string,
+	i18n: AdminI18n,
+	locales?: readonly string[]
+): VersionDiffRow {
+	const row: VersionDiffRow = {
+		path,
+		label,
+		before,
+		after,
+		field,
+		changed: !sameValue(before, after),
+	};
+	if (field.localized && locales) {
+		row.children = locales.map((locale) => ({
+			...compareField(
+				{ ...field, localized: false },
+				isRecord(before) ? before[locale] : undefined,
+				isRecord(after) ? after[locale] : undefined,
+				`${path}:${locale}`,
+				label,
+				i18n,
+				locales
+			),
+			locale,
+		}));
+		row.changed = row.children.some((child) => child.changed);
+	} else if (field.type === "group" && field.nested) {
+		row.children = compareFields(field.nested.fields, before, after, path, i18n, locales);
+		row.changed = row.children.some((child) => child.changed);
+	} else if ((field.type === "array" && field.nested) || field.blocks) {
+		const left = Array.isArray(before) ? before : [];
+		const right = Array.isArray(after) ? after : [];
+		const rowKey = (value: unknown, index: number) =>
+			isRecord(value) && typeof value._key === "string" ? value._key : String(index);
+		const leftKeys = left.map(rowKey);
+		const rightKeys = right.map(rowKey);
+		const keys = [...new Set([...rightKeys, ...leftKeys])];
+		const blocks = resolveBlockTypes(field.blocks);
+		row.children = keys.map((key, index) => {
+			const oldIndex = leftKeys.indexOf(key);
+			const newIndex = rightKeys.indexOf(key);
+			const oldValue = left[oldIndex];
+			const newValue = right[newIndex];
+			const value = newValue ?? oldValue;
+			const oldBlock = isRecord(oldValue)
+				? blocks.find((block) => block.slug === oldValue.blockType)
+				: undefined;
+			const block = isRecord(value)
+				? blocks.find((block) => block.slug === value.blockType)
+				: undefined;
+			const childPath = `${path}.${key}`;
+			// A type replacement may retain row identity. Keep removed fields from the old block visible.
+			const childFields = [
+				...new Map(
+					[...(oldBlock?.fields ?? []), ...(block?.fields ?? field.nested?.fields ?? [])].map(
+						(child) => [child.name, child]
+					)
+				).values(),
+			];
+			const labels = block?.labels ?? field.nested?.rowLabels;
+			const childLabel = `${labels ? i18n.text(labels.singular, labels.singularTranslations) : i18n.t("versions:row")} ${i18n.formatNumber(index + 1, { minimumIntegerDigits: 2 })}`;
+			const children = compareFields(childFields, oldValue, newValue, childPath, i18n, locales);
+			if (field.blocks) {
+				const oldType = isRecord(oldValue) ? oldValue.blockType : undefined;
+				const newType = isRecord(newValue) ? newValue.blockType : undefined;
+				children.unshift({
+					path: `${childPath}.blockType`,
+					label: i18n.t("versions:blockType"),
+					before: oldType,
+					after: newType,
+					changed: !sameValue(oldType, newType),
+				});
+			}
+			if (
+				field.blocks &&
+				((oldValue !== undefined && !oldBlock) || (newValue !== undefined && !block))
+			) {
+				children.push({
+					path: `${childPath}:content`,
+					label: i18n.t("versions:content"),
+					before: oldValue,
+					after: newValue,
+					changed: !sameValue(oldValue, newValue),
+				});
+			}
+			if (oldIndex !== newIndex) {
+				children.push({
+					path: `${childPath}:position`,
+					label: i18n.t("versions:position"),
+					before: oldIndex < 0 ? undefined : oldIndex + 1,
+					after: newIndex < 0 ? undefined : newIndex + 1,
+					changed: true,
+				});
+			}
+
 			return {
-				path,
-				label: i18n.text(field.admin.label || field.name, field.admin.labelTranslations),
-				before,
-				after,
-				changed: !sameValue(before, after),
+				path: childPath,
+				label: childLabel,
+				before: oldValue,
+				after: newValue,
+				changed: !sameValue(oldValue, newValue) || oldIndex !== newIndex,
+				children,
 			};
-		}),
-	];
+		});
+	}
+	return row;
 }
 
-export function formatVersionValue(value: unknown, i18n: AdminI18n): string {
-	if (value === undefined || value === null || value === "") return "—";
+export function formatVersionValue(value: unknown, i18n: AdminI18n, row?: VersionDiffRow): string {
+	if (value === undefined || value === null || value === "") return "";
+	if (row?.path === "_status")
+		return i18n.t(value === "published" ? "documents:published" : "documents:draft");
+	if (row?.field?.type === "date") return formatDateDisplay(value, row.field.date?.format, i18n);
+	if (["updatedAt", "createdAt", "deletedAt"].includes(row?.path ?? ""))
+		return versionDate(String(value), i18n);
 	if (typeof value === "string") return value;
 	if (typeof value === "number") return i18n.formatNumber(value);
 	if (typeof value === "boolean") return i18n.t(value ? "versions:true" : "versions:false");
+	if (row?.field?.plugin?.key === "richtext" || (isRecord(value) && isRecord(value.root))) {
+		const text = richText(value);
+		if (text) return text;
+	}
 	return JSON.stringify(value, null, 2);
 }
 
-function comparisonFields(fields: readonly SchemaField[]) {
-	return fields.flatMap((field): Array<{ field: SchemaField; path: string }> => {
-		if (field.type === "ui" || field.virtual !== undefined || field.join !== undefined) return [];
-		if (field.type === "group" && field.nested !== undefined) {
-			return comparisonFields(field.nested.fields);
-		}
-		return [{ field, path: field.path || field.name }];
-	});
+function richText(value: unknown): string {
+	if (!isRecord(value)) return "";
+	if (typeof value.text === "string") return value.text;
+	if (isRecord(value.root)) return richText(value.root);
+	if (!Array.isArray(value.children)) return "";
+	return value.children.map(richText).join(value.type === "root" ? "\n\n" : "");
 }
 
-function valueAtPath(document: AdminDocument | undefined, path: string): unknown {
-	let value: unknown = document;
-	for (const segment of path.split(".")) {
-		if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
-		value = Reflect.get(value, segment);
+export function sameValue(left: unknown, right: unknown): boolean {
+	if (left === right) return true;
+	if (Array.isArray(left) && Array.isArray(right))
+		return (
+			left.length === right.length && left.every((value, index) => sameValue(value, right[index]))
+		);
+	if (isRecord(left) && isRecord(right)) {
+		const keys = Object.keys(left);
+		return (
+			keys.length === Object.keys(right).length &&
+			keys.every((key) => Object.hasOwn(right, key) && sameValue(left[key], right[key]))
+		);
 	}
-	return value;
+	return false;
 }
 
-function sameValue(left: unknown, right: unknown) {
-	return JSON.stringify(left) === JSON.stringify(right);
+/** Keep unchanged words readable; bound the LCS matrix for large code and rich-text values. */
+export function versionTextDiff(before: string, after: string) {
+	const left = before.split(/(\s+|[.,;:!?()[\]{}])/).filter(Boolean);
+	const right = after.split(/(\s+|[.,;:!?()[\]{}])/).filter(Boolean);
+	let start = 0;
+	while (start < left.length && start < right.length && left[start] === right[start]) start++;
+	let end = 0;
+	while (
+		end < left.length - start &&
+		end < right.length - start &&
+		left[left.length - end - 1] === right[right.length - end - 1]
+	)
+		end++;
+	const a = left.slice(start, left.length - end);
+	const b = right.slice(start, right.length - end);
+	const oldParts: { text: string; changed: boolean }[] = [];
+	const newParts: { text: string; changed: boolean }[] = [];
+	const add = (parts: typeof oldParts, text: string, changed: boolean) => {
+		if (!text) return;
+		const last = parts.at(-1);
+		if (last?.changed === changed) last.text += text;
+		else parts.push({ text, changed });
+	};
+	add(oldParts, left.slice(0, start).join(""), false);
+	add(newParts, right.slice(0, start).join(""), false);
+	if (a.length * b.length > 40_000) {
+		add(oldParts, a.join(""), true);
+		add(newParts, b.join(""), true);
+	} else {
+		const lengths = Array.from({ length: a.length + 1 }, () => new Uint32Array(b.length + 1));
+		for (let i = a.length - 1; i >= 0; i--)
+			for (let j = b.length - 1; j >= 0; j--)
+				lengths[i]![j] =
+					a[i] === b[j]
+						? 1 + lengths[i + 1]![j + 1]!
+						: Math.max(lengths[i + 1]![j]!, lengths[i]![j + 1]!);
+		let i = 0,
+			j = 0;
+		while (i < a.length || j < b.length) {
+			if (i < a.length && j < b.length && a[i] === b[j]) {
+				add(oldParts, a[i++]!, false);
+				add(newParts, b[j++]!, false);
+			} else if (i < a.length && (j === b.length || lengths[i + 1]![j]! >= lengths[i]![j + 1]!))
+				add(oldParts, a[i++]!, true);
+			else add(newParts, b[j++]!, true);
+		}
+	}
+	add(oldParts, end ? left.slice(-end).join("") : "", false);
+	add(newParts, end ? right.slice(-end).join("") : "", false);
+	return { before: oldParts, after: newParts };
+}
+
+export function versionReferences(row: VersionDiffRow, value: unknown) {
+	const reference = row.field?.relationship ?? row.field?.upload;
+	if (!reference) return [];
+	return (
+		Array.isArray(value) ? value : value === undefined || value === null ? [] : [value]
+	).flatMap((item) => {
+		const collection =
+			isRecord(item) && typeof item.relationTo === "string"
+				? item.relationTo
+				: reference.collectionSlug;
+		const id = isRecord(item) ? item.id : item;
+		return collection && (typeof id === "string" || typeof id === "number")
+			? [{ collection, id: String(id), key: `${collection}:${id}` }]
+			: [];
+	});
 }

package/src/features/versions/version-history-controller.svelte.ts

@@ -0,0 +1,311 @@
+import { RiduError } from "@riducms/sdk";
+import type { AdminVersionsDataV1, OperationCapabilities } from "@riducms/protocol";
+import type { AdminDocument, AdminVersion } from "@admin/core/api/admin-client";
+import type { AdminRuntime } from "@admin/core/runtime/admin-runtime.svelte";
+import type { NotificationCenter } from "@admin/core/notifications/notification-center.svelte";
+
+export interface VersionHistoryTarget {
+	slug: string;
+	id: string;
+	global: boolean;
+	revision?: number;
+	locale?: string;
+}
+
+export type VersionComparisonState =
+	| { revision: number; status: "loading" }
+	| { revision: number; status: "ready"; version: AdminVersion }
+	| { revision: number; status: "error"; error: string };
+
+/** One visit owns its reads and restore result, including when the route component is retained. */
+export class VersionHistoryController {
+	#runtime: AdminRuntime;
+	#notifications: NotificationCenter;
+	#target?: VersionHistoryTarget;
+	#loadRequest?: AbortController;
+	#comparisonRequest?: AbortController;
+	#comparisonSummary?: AdminVersion;
+	#visit = 0;
+	#key = "";
+	#history = $state.raw<AdminVersion[]>([]);
+	#detail = $state.raw<AdminVersion>();
+	#document = $state.raw<AdminDocument>();
+	#operations = $state.raw<OperationCapabilities>();
+	#loading = $state(true);
+	#error = $state<string>();
+	#failureStatus = $state<number>();
+	#restoring = $state(false);
+	#comparisonState = $state.raw<VersionComparisonState>();
+
+	constructor(runtime: AdminRuntime, notifications: NotificationCenter) {
+		this.#runtime = runtime;
+		this.#notifications = notifications;
+	}
+
+	get versions() {
+		return this.#history;
+	}
+	get selectedVersion() {
+		return this.#detail;
+	}
+	get document() {
+		return this.#document;
+	}
+	get loading() {
+		return this.#loading;
+	}
+	get error() {
+		return this.#error;
+	}
+	get canRetry() {
+		return ![401, 403, 404].includes(this.#failureStatus ?? 0);
+	}
+	get restoring() {
+		return this.#restoring;
+	}
+	get comparisonState() {
+		return this.#comparisonState;
+	}
+
+	sync = (
+		target: VersionHistoryTarget,
+		manifestRevision: number,
+		prepared?: AdminVersionsDataV1
+	) => {
+		const key = JSON.stringify([target, manifestRevision]);
+		if (key === this.#key) return;
+		this.#key = key;
+		this.#target = target;
+		this.#visit++;
+		this.#restoring = false;
+		this.#loadRequest?.abort();
+		this.#clear();
+
+		if (prepared) {
+			const { history, detail, document } = prepared;
+			const detailMissing = detail?.error?.code === "not_found";
+			const failure =
+				history.error ??
+				(detailMissing ? undefined : detail?.error) ??
+				document.document.error ??
+				document.access.error;
+			if (failure) {
+				this.#error = failure.message;
+				this.#failureStatus = failure.status;
+				this.#loading = false;
+				return;
+			}
+			if (
+				history.value &&
+				document.document.value &&
+				document.access.value &&
+				(target.revision === undefined || detail?.value || detailMissing)
+			) {
+				this.#apply(
+					history.value,
+					detail?.value,
+					document.document.value,
+					document.access.value.operations
+				);
+				return;
+			}
+		}
+		this.#load(target);
+	};
+
+	retry = () => {
+		if (this.#target && !this.#restoring) this.#load(this.#target);
+	};
+
+	syncComparison = async (summary: AdminVersion | undefined) => {
+		const target = this.#target;
+		if (!summary || !target || summary.Revision === this.#detail?.Revision) {
+			this.#clearComparison();
+			return;
+		}
+		if (this.#comparisonState?.revision === summary.Revision) return;
+
+		this.#comparisonRequest?.abort();
+		this.#comparisonSummary = summary;
+		if (!this.#runtime.contentLocales.length) {
+			this.#comparisonState = { revision: summary.Revision, status: "ready", version: summary };
+			this.#comparisonRequest = undefined;
+			return;
+		}
+
+		this.#comparisonState = { revision: summary.Revision, status: "loading" };
+		const request = new AbortController();
+		this.#comparisonRequest = request;
+		const options = { signal: request.signal, locale: "all" };
+		try {
+			const version = target.global
+				? await this.#runtime.client.globalVersion(target.slug, summary.Revision, options)
+				: await this.#runtime.client.version(target.slug, target.id, summary.Revision, options);
+			if (!request.signal.aborted)
+				this.#comparisonState = { revision: summary.Revision, status: "ready", version };
+		} catch (cause) {
+			if (!request.signal.aborted)
+				this.#comparisonState = {
+					revision: summary.Revision,
+					status: "error",
+					error:
+						cause instanceof Error
+							? cause.message
+							: this.#runtime.i18n.t("versions:historyLoadFailed"),
+				};
+		} finally {
+			if (this.#comparisonRequest === request) this.#comparisonRequest = undefined;
+		}
+	};
+
+	retryComparison = async () => {
+		const state = this.#comparisonState;
+		const summary = this.#comparisonSummary;
+		if (state?.status !== "error" || !summary) return;
+		this.#comparisonState = undefined;
+		await this.syncComparison(summary);
+	};
+
+	async #load(target: VersionHistoryTarget) {
+		this.#loadRequest?.abort();
+		const request = new AbortController();
+		this.#loadRequest = request;
+		this.#loading = true;
+		this.#error = undefined;
+		const { client, i18n } = this.#runtime;
+		const { slug, id, global, revision, locale } = target;
+		const historyOptions = {
+			signal: request.signal,
+			locale,
+		};
+		const detailOptions = {
+			signal: request.signal,
+			locale: this.#runtime.contentLocales.length ? "all" : undefined,
+		};
+		const detailRequest =
+			revision === undefined
+				? Promise.resolve(undefined)
+				: (global
+						? client.globalVersion(slug, revision, detailOptions)
+						: client.version(slug, id, revision, detailOptions)
+					).catch((cause) => {
+						if (cause instanceof RiduError && cause.code === "not_found") return undefined;
+						throw cause;
+					});
+		try {
+			const [history, detail, document, access] = await Promise.all([
+				global
+					? client.globalVersions(slug, historyOptions)
+					: client.versions(slug, id, historyOptions),
+				detailRequest,
+				global
+					? client.global(slug, { signal: request.signal, locale })
+					: client.find(slug, id, { signal: request.signal, locale }),
+				global
+					? client.globalAccess(slug, { signal: request.signal, locale })
+					: client.collectionAccess(slug, { id, signal: request.signal, locale }),
+			]);
+			if (request.signal.aborted) return;
+			this.#apply(history, detail, document, access.operations);
+		} catch (cause) {
+			if (request.signal.aborted) return;
+			this.#clear();
+			this.#failureStatus = cause instanceof RiduError ? cause.status : undefined;
+			this.#error = cause instanceof Error ? cause.message : i18n.t("versions:historyLoadFailed");
+		} finally {
+			if (!request.signal.aborted) this.#loading = false;
+		}
+	}
+
+	#clear() {
+		this.#clearComparison();
+		this.#history = [];
+		this.#detail = undefined;
+		this.#document = undefined;
+		this.#operations = undefined;
+		this.#error = undefined;
+		this.#failureStatus = undefined;
+		this.#loading = true;
+	}
+
+	#clearComparison() {
+		this.#comparisonRequest?.abort();
+		this.#comparisonRequest = undefined;
+		this.#comparisonSummary = undefined;
+		this.#comparisonState = undefined;
+	}
+
+	#apply(
+		history: AdminVersion[],
+		detail: AdminVersion | undefined,
+		document: AdminDocument,
+		operations: OperationCapabilities
+	) {
+		// Detail is an exact authorized read, not a fallback to a potentially stale list snapshot.
+		this.#detail = detail;
+		this.#history = [...history].sort((a, b) => b.Revision - a.Revision);
+		this.#document = document;
+		this.#operations = operations;
+		this.#loading = false;
+	}
+
+	canRestore(draft: boolean) {
+		const revision = this.#document?._revision;
+		const operation = draft || this.#detail?.Status === "draft" ? "unpublish" : "publish";
+		return (
+			Number.isInteger(revision) && Number(revision) > 0 && this.#operations?.[operation] === true
+		);
+	}
+
+	restore = async (draft: boolean, onRestored: () => void) => {
+		const target = this.#target;
+		const selected = this.#detail;
+		const document = this.#document;
+		if (
+			!target ||
+			!selected ||
+			!document ||
+			this.#loading ||
+			this.#restoring ||
+			!this.canRestore(draft)
+		)
+			return;
+		const { slug, id, global, locale } = target;
+		const visit = this.#visit;
+		const { client, i18n } = this.#runtime;
+		this.#restoring = true;
+		this.#loadRequest?.abort();
+		try {
+			const options = {
+				revision: document._revision as number,
+				draft,
+				locale,
+			};
+			if (global) await client.restoreGlobal(slug, selected.Revision, options);
+			else await client.restore(slug, id, selected.Revision, options);
+			if (visit !== this.#visit) return;
+			this.#runtime.documentsChanged();
+			this.#notifications.success({
+				title: i18n.t(draft ? "versions:revisionRestoredAsDraft" : "versions:revisionRestored", {
+					revision: i18n.formatNumber(selected.Revision),
+				}),
+				message: i18n.t("versions:previousCurrentPreserved"),
+			});
+			onRestored();
+		} catch (cause) {
+			if (visit !== this.#visit) return;
+			this.#notifications.error({
+				title: i18n.t("versions:revisionNotRestored"),
+				message: cause instanceof Error ? cause.message : i18n.t("versions:revisionRestoreFailed"),
+			});
+		} finally {
+			if (visit === this.#visit) this.#restoring = false;
+		}
+	};
+
+	dispose = () => {
+		this.#visit++;
+		this.#loadRequest?.abort();
+		this.#comparisonRequest?.abort();
+	};
+}