@riducms/admin 0.1.5 → 0.2.1

package/src/core/forms/form-issue-correlation.ts

@@ -0,0 +1,159 @@
+import { resolveBlockTypes } from "@riducms/protocol";
+import type { SchemaField, ValidationIssue } from "@riducms/protocol";
+import { embeddedOccurrences, isEmbeddedRecord } from "@admin/core/forms/embedded-fields";
+
+export interface FieldValueLocation {
+	schema?: SchemaField;
+	path: string;
+	token: string;
+	value: unknown;
+}
+
+/** Go and JavaScript may spell the same JSON string differently (notably U+2028/2029). */
+export function canonicalIssueTarget(target: string): string | undefined {
+	try {
+		const segments: unknown = JSON.parse(target);
+		return Array.isArray(segments) && segments.every((segment) => typeof segment === "string")
+			? JSON.stringify(segments)
+			: undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Issues describe the submitted snapshot. Follow stable occurrences, never current indexes. */
+export function correlateFormIssues(
+	fields: readonly SchemaField[],
+	before: Record<string, unknown>,
+	after: Record<string, unknown>,
+	issues: readonly ValidationIssue[]
+) {
+	return correlate(indexFieldValues(fields, before), indexFieldValues(fields, after), issues);
+}
+
+export function correlateEmbeddedIssues(
+	field: SchemaField,
+	before: unknown,
+	after: unknown,
+	issues: readonly ValidationIssue[]
+) {
+	const relevant = issues.filter(
+		(issue) => issue.path === field.path || issue.path.startsWith(`${field.path}.`)
+	);
+	if (relevant.length === 0) return [];
+	return correlate(
+		indexFieldValues([field], { [field.name]: before }),
+		indexFieldValues([field], { [field.name]: after }),
+		relevant,
+		false
+	);
+}
+
+export function indexFieldValues(fields: readonly SchemaField[], values: Record<string, unknown>) {
+	const locations: FieldValueLocation[] = [];
+	const add = (path: string, token: readonly string[], value: unknown, schema?: SchemaField) =>
+		locations.push({
+			path,
+			token: JSON.stringify(token),
+			value,
+			...(schema === undefined ? {} : { schema }),
+		});
+	const record = (
+		children: readonly SchemaField[],
+		value: unknown,
+		path: string,
+		token: readonly string[]
+	) => {
+		if (!isEmbeddedRecord(value)) return;
+		for (const child of children)
+			visit(child, value[child.name], `${path}.${child.name}`, [...token, child.id]);
+	};
+	const visit = (field: SchemaField, value: unknown, path: string, token: readonly string[]) => {
+		add(path, token, value, field);
+		if (field.type === "group") record(field.nested?.fields ?? [], value, path, token);
+		if ((field.type === "array" || field.type === "blocks") && Array.isArray(value)) {
+			const keys = new Map<string, number>();
+			for (const row of value) {
+				if (isEmbeddedRecord(row) && typeof row._key === "string")
+					keys.set(row._key, (keys.get(row._key) ?? 0) + 1);
+			}
+			for (const [i, row] of value.entries()) {
+				if (!isEmbeddedRecord(row) || typeof row._key !== "string" || keys.get(row._key) !== 1)
+					continue;
+				const block = resolveBlockTypes(field.blocks).find(
+					(candidate) => candidate.slug === row.blockType
+				);
+				const next = [...token, row._key, block?.slug ?? ""];
+				add(`${path}.${i}`, next, row);
+				record(block?.fields ?? field.nested?.fields ?? [], row, `${path}.${i}`, next);
+			}
+		}
+		if (field.plugin?.embeddedTrees !== undefined) {
+			const result = embeddedOccurrences(field, value, path);
+			if (result.issues.length > 0) return;
+			for (const occurrence of result.occurrences) {
+				if (occurrence.identity === undefined) continue;
+				const next = [
+					...token,
+					occurrence.tree.key,
+					occurrence.case.tagValue,
+					occurrence.block.slug,
+					occurrence.identity,
+				];
+				add(occurrence.path, next, occurrence.payload);
+				record(occurrence.block.fields, occurrence.payload, occurrence.path, next);
+			}
+		}
+	};
+	for (const field of fields) visit(field, values[field.name], field.path, [field.id]);
+	return locations;
+}
+
+function correlate(
+	before: FieldValueLocation[],
+	after: FieldValueLocation[],
+	issues: readonly ValidationIssue[],
+	useTargets = true
+) {
+	const previous = new Map(before.map((location) => [location.path, location]));
+	const previousTargets = new Map(before.map((location) => [location.token, location]));
+	const current = new Map(after.map((location) => [location.token, location]));
+	return issues.flatMap((issue) => {
+		if (useTargets && issue.target !== undefined) {
+			// The server may transform/reorder its final candidate before validation. Its
+			// display path then describes that candidate, not our submitted snapshot.
+			const token = canonicalIssueTarget(issue.target);
+			if (token === undefined) return [];
+			const source = previousTargets.get(token);
+			const target = current.get(token);
+			if (!source || !target || JSON.stringify(source.value) !== JSON.stringify(target.value))
+				return [];
+			return [{ ...issue, path: target.path }];
+		}
+		let path = issue.path;
+		while (!previous.has(path) && path.includes(".")) path = path.slice(0, path.lastIndexOf("."));
+		const source = previous.get(path);
+		if (source === undefined) return [issue];
+		const target = current.get(source.token);
+		if (target === undefined) return [];
+		const suffix = issue.path.slice(source.path.length);
+		// An envelope index without a schema-owned identity is ambiguous after edits.
+		if (
+			/\.\d+(?:\.|$)/.test(suffix) &&
+			JSON.stringify(source.value) !== JSON.stringify(target.value)
+		)
+			return [];
+		if (JSON.stringify(at(source.value, suffix)) !== JSON.stringify(at(target.value, suffix)))
+			return [];
+		return [{ ...issue, path: target.path + suffix }];
+	});
+}
+
+function at(value: unknown, suffix: string) {
+	for (const segment of suffix.split(".").filter(Boolean)) {
+		if (Array.isArray(value)) value = value[Number(segment)];
+		else if (isEmbeddedRecord(value)) value = value[segment];
+		else return undefined;
+	}
+	return value;
+}

package/src/core/forms/form-schema.ts

@@ -1,3 +1,5 @@
+import { resolveBlockTypes } from "@riducms/protocol";
+import { embeddedOccurrences, transformEmbeddedPayloads } from "@admin/core/forms/embedded-fields";
 import type { SchemaField } from "@riducms/protocol";
 
 export type FormValues = Record<string, unknown>;
@@ -31,9 +33,10 @@ export function localizationSource(
 	path: string,
 	values: FormValues,
 	original: FormValues,
-	sources: Readonly<Record<string, string>>
+	sources: Readonly<Record<string, string>>,
+	fields: readonly SchemaField[] = []
 ) {
-	return sources[localizationProvenancePath(path, values, original)];
+	return sources[localizationProvenancePath(path, values, original, fields)];
 }
 
 export function shouldSubmitLocalizedPath(
@@ -41,9 +44,10 @@ export function shouldSubmitLocalizedPath(
 	values: FormValues,
 	original: FormValues,
 	locale: string | undefined,
-	sources: Readonly<Record<string, string>>
+	sources: Readonly<Record<string, string>>,
+	fields: readonly SchemaField[] = []
 ) {
-	const provenancePath = localizationProvenancePath(path, values, original);
+	const provenancePath = localizationProvenancePath(path, values, original, fields);
 	const source = sources[provenancePath];
 	return (
 		source === undefined ||
@@ -60,10 +64,18 @@ export function submissionFormValues(
 	return submissionRecord(fields, input, "", include);
 }
 
-export function initialFormValues(fields: readonly SchemaField[]): FormValues {
-	const values: FormValues = {};
+/** Initialize a new record, retaining supplied values and container metadata. */
+export function initialFormValues(
+	fields: readonly SchemaField[],
+	input: FormValues = {}
+): FormValues {
+	const values = cloneFormValues(input);
 	for (const field of fields) {
-		const defaultValue = initialFieldValue(field);
+		const defaultValue = initialFieldValue(
+			field,
+			input[field.name],
+			Object.hasOwn(input, field.name)
+		);
 		if (defaultValue.present) values[field.name] = cloneFormValue(defaultValue.value);
 	}
 	return values;
@@ -108,9 +120,31 @@ function submissionRecord(
 		} else if (field.type === "blocks" && Array.isArray(value)) {
 			submitted[field.name] = value.map((row, index) => {
 				if (!isRecord(row) || typeof row.blockType !== "string") return cloneFormValue(row);
-				const block = field.blocks?.types.find((candidate) => candidate.key === row.blockType);
-				return submissionRecord(block?.fields ?? [], row, `${path}.${index}`, include);
+				const block = resolveBlockTypes(field.blocks).find(
+					(candidate) => candidate.slug === row.blockType
+				);
+				return block === undefined
+					? cloneFormValue(row)
+					: submissionRecord(block.fields, row, `${path}.${index}`, include);
 			});
+		} else if (field.type === "plugin" && field.plugin?.embeddedTrees !== undefined) {
+			submitted[field.name] = transformEmbeddedPayloads(
+				field,
+				cloneFormValue(value),
+				path,
+				(occurrence) => ({
+					...submissionRecord(
+						occurrence.block.fields,
+						occurrence.payload,
+						occurrence.path,
+						include
+					),
+					[occurrence.case.discriminator]: occurrence.block.slug,
+					...(occurrence.identity === undefined
+						? {}
+						: { [occurrence.case.identity]: occurrence.identity }),
+				})
+			);
 		} else {
 			submitted[field.name] = cloneFormValue(value);
 		}
@@ -120,7 +154,14 @@ function submissionRecord(
 	return submitted;
 }
 
-function localizationProvenancePath(path: string, values: FormValues, originalValues: FormValues) {
+function localizationProvenancePath(
+	path: string,
+	values: FormValues,
+	originalValues: FormValues,
+	fields: readonly SchemaField[] = []
+) {
+	const embeddedPath = embeddedProvenancePath(fields, values, originalValues, path);
+	if (embeddedPath !== undefined) return embeddedPath;
 	const segments = path.split(".");
 	const resolved: string[] = [];
 	let current: unknown = values;
@@ -358,6 +399,58 @@ function reconcileFieldValue(
 		);
 	}
 
+	if (
+		previous.type === "plugin" &&
+		next.type === "plugin" &&
+		next.plugin?.embeddedTrees !== undefined
+	) {
+		const reconcilePayloads = (value: unknown, before: unknown, report: DetachedDraftValue[]) => {
+			const copy = cloneFormValue(value);
+			const fieldPath = joinPath(parentPath, next.name);
+			const old = embeddedOccurrences(previous, before, fieldPath);
+			const currentOld = embeddedOccurrences(previous, value, fieldPath);
+			const candidates = embeddedOccurrences(next, copy, fieldPath);
+			// Unknown definitions remain intact for the submission recovery guard.
+			if (candidates.issues.length > 0) return copy;
+			return transformEmbeddedPayloads(next, copy, fieldPath, (occurrence) => {
+				const match = (candidate: (typeof old.occurrences)[number]) =>
+					candidate.tree.key === occurrence.tree.key &&
+					candidate.case.tagValue === occurrence.case.tagValue &&
+					candidate.block.slug === occurrence.block.slug &&
+					candidate.identity === occurrence.identity;
+				const prior = old.occurrences.find(match);
+				const previousOccurrence = currentOld.occurrences.find(match);
+				if (previousOccurrence === undefined)
+					return {
+						...(initializeDefaults ? initialFormValues(occurrence.block.fields) : {}),
+						...occurrence.payload,
+					};
+				const priorSchema = previousOccurrence.block.fields;
+				const reconciled = reconcileRecord(
+					priorSchema,
+					occurrence.block.fields,
+					occurrence.payload,
+					prior?.payload,
+					report,
+					occurrence.path,
+					initializeDefaults
+				);
+				return {
+					...reconciled.values,
+					[occurrence.case.discriminator]: occurrence.block.slug,
+					...(occurrence.identity === undefined
+						? {}
+						: { [occurrence.case.identity]: occurrence.identity }),
+				};
+			});
+		};
+		return {
+			currentPresent,
+			current: reconcilePayloads(currentValue, originalValue, detached),
+			originalPresent,
+			original: reconcilePayloads(originalValue, originalValue, []),
+		};
+	}
 	return {
 		currentPresent,
 		current: cloneFormValue(currentValue),
@@ -442,13 +535,20 @@ function reconcileBlocksValue(
 	}
 	const currentRows = Array.isArray(currentValue) ? currentValue : [];
 	const originalRows = Array.isArray(originalValue) ? originalValue : [];
-	const previousBlocks = new Map((previous.blocks?.types ?? []).map((block) => [block.key, block]));
-	const nextBlocks = new Map((next.blocks?.types ?? []).map((block) => [block.key, block]));
+	const previousBlocks = new Map(
+		(resolveBlockTypes(previous.blocks) ?? []).map((block) => [block.slug, block])
+	);
+	const nextBlocks = new Map(
+		(resolveBlockTypes(next.blocks) ?? []).map((block) => [block.slug, block])
+	);
 	const rowPath = joinPath(parentPath, next.name);
-	const keptCurrent: FormValues[] = [];
+	const keptCurrent: unknown[] = [];
 
 	for (const [index, row] of currentRows.entries()) {
-		if (!isRecord(row)) continue;
+		if (!isRecord(row)) {
+			keptCurrent.push(cloneFormValue(row));
+			continue;
+		}
 		const blockType = String(row.blockType ?? "");
 		const previousBlock = previousBlocks.get(blockType);
 		const nextBlock = nextBlocks.get(blockType);
@@ -463,6 +563,7 @@ function reconcileBlocksValue(
 					value: cloneFormValue(row),
 				});
 			}
+			keptCurrent.push(cloneFormValue(row));
 			continue;
 		}
 		keptCurrent.push(
@@ -479,11 +580,11 @@ function reconcileBlocksValue(
 	}
 
 	const keptOriginal = originalRows.flatMap((row, index) => {
-		if (!isRecord(row)) return [];
+		if (!isRecord(row)) return [cloneFormValue(row)];
 		const blockType = String(row.blockType ?? "");
 		const previousBlock = previousBlocks.get(blockType);
 		const nextBlock = nextBlocks.get(blockType);
-		if (previousBlock === undefined || nextBlock === undefined) return [];
+		if (previousBlock === undefined || nextBlock === undefined) return [cloneFormValue(row)];
 		return [
 			reconcileRecord(
 				previousBlock.fields,
@@ -530,12 +631,40 @@ function fieldDefault(field: SchemaField) {
 		return { present: true, value: field.select.defaultValues };
 	}
 	if (field.default === undefined) return { present: false };
+	if (field.type === "text-list" || field.type === "number-list")
+		return { present: true, value: JSON.parse(field.default) };
 	if (field.type === "number") return { present: true, value: Number(field.default) };
 	if (field.type === "checkbox") return { present: true, value: field.default === "true" };
 	return { present: true, value: field.default };
 }
 
-function initialFieldValue(field: SchemaField): { present: boolean; value?: unknown } {
+function initialFieldValue(
+	field: SchemaField,
+	value?: unknown,
+	present = false
+): { present: boolean; value?: unknown } {
+	if (present) {
+		if (field.type === "group" && isRecord(value)) {
+			value = initialFormValues(field.nested?.fields ?? [], value);
+		} else if (field.type === "array" && Array.isArray(value)) {
+			value = value.map((row) =>
+				isRecord(row) ? initialFormValues(field.nested?.fields ?? [], row) : row
+			);
+		} else if (field.type === "blocks" && Array.isArray(value)) {
+			value = value.map((row) => {
+				if (!isRecord(row)) return row;
+				const block = resolveBlockTypes(field.blocks).find(
+					(candidate) => candidate.slug === row.blockType
+				);
+				return block === undefined ? row : initialFormValues(block.fields, row);
+			});
+		} else if (field.type === "plugin" && field.plugin?.embeddedTrees !== undefined) {
+			value = transformEmbeddedPayloads(field, cloneFormValue(value), field.path, (occurrence) =>
+				initialFormValues(occurrence.block.fields, occurrence.payload)
+			);
+		}
+		return { present: true, value };
+	}
 	const direct = fieldDefault(field);
 	if (direct.present) return direct;
 	if (field.type === "group") {
@@ -607,3 +736,68 @@ export function cloneFormValue(value: unknown): unknown {
 	}
 	return value;
 }
+
+function embeddedProvenancePath(
+	fields: readonly SchemaField[],
+	current: FormValues,
+	original: FormValues,
+	path: string,
+	prefix = ""
+): string | undefined {
+	for (const field of fields) {
+		const fieldPath = joinPath(prefix, field.name);
+		if (!path.startsWith(`${fieldPath}.`)) continue;
+		const value = current[field.name];
+		const before = original[field.name];
+		if (field.type === "plugin") {
+			const now = embeddedOccurrences(field, value, fieldPath);
+			const previous = embeddedOccurrences(field, before, fieldPath);
+			const occurrence = now.occurrences.find((candidate) => path.startsWith(`${candidate.path}.`));
+			if (occurrence !== undefined && occurrence.identity !== undefined) {
+				const match = previous.occurrences.find(
+					(candidate) =>
+						candidate.tree.key === occurrence.tree.key &&
+						candidate.case.tagValue === occurrence.case.tagValue &&
+						candidate.block.slug === occurrence.block.slug &&
+						candidate.identity === occurrence.identity
+				);
+				if (match !== undefined) {
+					const suffix = path.slice(occurrence.path.length + 1);
+					return `${match.path}.${localizationProvenancePath(suffix, occurrence.payload, match.payload, occurrence.block.fields)}`;
+				}
+				return "";
+			}
+		}
+		if (field.type === "group" && isRecord(value))
+			return embeddedProvenancePath(
+				field.nested?.fields ?? [],
+				value,
+				isRecord(before) ? before : {},
+				path,
+				fieldPath
+			);
+		if ((field.type === "array" || field.type === "blocks") && Array.isArray(value)) {
+			for (const [index, row] of value.entries()) {
+				if (!isRecord(row) || !path.startsWith(`${fieldPath}.${index}.`)) continue;
+				const prior = Array.isArray(before) ? matchingRow(row, before, index) : {};
+				const children =
+					field.type === "blocks"
+						? (resolveBlockTypes(field.blocks).find((block) => block.slug === row.blockType)
+								?.fields ?? [])
+						: (field.nested?.fields ?? []);
+				const resolved = embeddedProvenancePath(
+					children,
+					row,
+					isRecord(prior) ? prior : {},
+					path,
+					`${fieldPath}.${index}`
+				);
+				const priorIndex = Array.isArray(before) ? before.indexOf(prior) : -1;
+				return resolved === undefined || priorIndex < 0
+					? resolved
+					: resolved.replace(`${fieldPath}.${index}.`, `${fieldPath}.${priorIndex}.`);
+			}
+		}
+	}
+	return undefined;
+}