@riducms/admin 0.1.5 → 0.2.1

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

@@ -1,4 +1,7 @@
+import { resolveBlockTypes } from "@riducms/protocol";
+import { embeddedOccurrences } from "@admin/core/forms/embedded-fields";
 import type { AdminI18n } from "@riducms/plugin";
+import { createAdminI18n } from "@riducms/translations";
 import type { SchemaField, ValidationIssue } from "@riducms/protocol";
 
 import { initialFormValues, type FormValues } from "@admin/core/forms/form-schema";
@@ -92,7 +95,7 @@ function resolveFieldLabel(
 					),
 				]
 			: labels;
-		const blockFields = field.blocks.types.flatMap((block) => block.fields);
+		const blockFields = resolveBlockTypes(field.blocks).flatMap((block) => block.fields);
 		return resolveFieldLabel(
 			blockFields,
 			isIndex(index) ? childSegments : remaining,
@@ -126,8 +129,14 @@ function validateFields(
 			const defaults = requireMissing ? initialFormValues([field]) : {};
 			if (Object.hasOwn(defaults, field.name)) {
 				validateFields([field], defaults, prefix, true, issues, include, i18n);
-			} else if (requireMissing && field.required) {
+			} else if (requireMissing && field.required && !field.dynamicDefault) {
 				issues.push(requiredIssue(field, path, i18n));
+			} else if (
+				requireMissing &&
+				!field.dynamicDefault &&
+				(field.type === "text-list" || field.type === "number-list")
+			) {
+				validatePrimitiveList(field, [], path, issues, i18n);
 			} else if (requireMissing && field.type === "array" && (field.nested?.minRows ?? 0) > 0) {
 				issues.push(
 					issue(
@@ -146,6 +155,8 @@ function validateFields(
 		}
 		if (value === null || value === undefined) {
 			if (field.required) issues.push(requiredIssue(field, path, i18n));
+			else if (field.type === "text-list" || field.type === "number-list")
+				validatePrimitiveList(field, [], path, issues, i18n);
 			else if (field.type === "array" && (field.nested?.minRows ?? 0) > 0) {
 				issues.push(
 					issue(
@@ -164,6 +175,10 @@ function validateFields(
 		}
 
 		switch (field.type) {
+			case "text-list":
+			case "number-list":
+				validatePrimitiveList(field, value, path, issues, i18n);
+				break;
 			case "text":
 			case "code":
 			case "textarea":
@@ -242,14 +257,75 @@ function validateFields(
 			case "blocks":
 				validateBlocks(field, value, path, issues, include, i18n);
 				break;
+			case "plugin": {
+				const embedded = embeddedOccurrences(field, value, path);
+				issues.push(...embedded.issues);
+				for (const occurrence of embedded.occurrences)
+					validateFields(
+						occurrence.block.fields,
+						occurrence.payload,
+						occurrence.path,
+						true,
+						issues,
+						include,
+						i18n
+					);
+				break;
+			}
 			case "json":
-			case "plugin":
-				// Plugin validators and internal populated-document checks remain server-authoritative.
+				// Plugin envelope validators and populated-document checks remain server-authoritative.
 				break;
 		}
 	}
 }
 
+function validatePrimitiveList(
+	field: SchemaField,
+	value: unknown,
+	path: string,
+	issues: ValidationIssue[],
+	i18n: AdminI18n = createAdminI18n()
+) {
+	const label = localizedFieldLabel(field, i18n);
+	const report = (
+		code: string,
+		key: Parameters<AdminI18n["t"]>[0],
+		variables: Readonly<Record<string, string | number>> = {}
+	) => issues.push(issue(code, path, i18n.t(key, { label, ...variables })));
+	if (!Array.isArray(value)) {
+		report("invalid_type", "errors:array");
+		return;
+	}
+	const minimum = Math.max(field.required ? 1 : 0, field.list?.minRows ?? 0);
+	if (value.length < minimum)
+		report(field.required && value.length === 0 ? "required" : "min_rows", "errors:listMinItems", {
+			count: minimum,
+		});
+	if (field.list?.maxRows && value.length > field.list.maxRows)
+		report("max_rows", "errors:listMaxItems", { count: field.list.maxRows });
+	for (const [index, item] of value.entries()) {
+		const number = index + 1;
+		if (field.type === "text-list") {
+			if (typeof item !== "string") {
+				report("invalid_type", "errors:listItemString", { number });
+				continue;
+			}
+			const length = Array.from(item).length;
+			if (length < (field.text?.minLength ?? 0))
+				report("min_length", "errors:listItemMinLength", { number, count: field.text!.minLength! });
+			if (field.text?.maxLength !== undefined && length > field.text.maxLength)
+				report("max_length", "errors:listItemMaxLength", { number, count: field.text.maxLength });
+		} else if (typeof item !== "number" || !Number.isFinite(item))
+			report("invalid_number", "errors:listItemNumber", { number });
+		else {
+			if (field.number?.min !== undefined && item < field.number.min)
+				report("min_value", "errors:listItemMin", { number, min: field.number.min });
+			if (field.number?.max !== undefined && item > field.number.max)
+				report("max_value", "errors:listItemMax", { number, max: field.number.max });
+		}
+	}
+}
+
 function validateString(
 	field: SchemaField,
 	value: unknown,
@@ -330,16 +406,16 @@ function validateSelect(
 		if (field.required) issues.push(requiredIssue(field, path, i18n));
 		return;
 	}
-	if (!field.select?.choices.some((choice) => choice.value === value)) {
+	if (!field.select?.options.some((option) => option.value === value)) {
 		issues.push(
 			issue(
-				"invalid_choice",
+				"invalid_option",
 				path,
 				translate(
 					i18n,
-					"errors:allowedChoice",
+					"errors:allowedOption",
 					{ label: localizedFieldLabel(field, i18n) },
-					`${localizedFieldLabel(field, i18n)} is not an allowed choice`
+					`${localizedFieldLabel(field, i18n)} is not an allowed option`
 				)
 			)
 		);
@@ -373,7 +449,7 @@ function validateSelectMany(
 		return;
 	}
 
-	const choices = new Set((field.select?.choices ?? []).map((choice) => choice.value));
+	const options = new Set((field.select?.options ?? []).map((option) => option.value));
 	const seen = new Set<string>();
 	for (const [index, candidate] of value.entries()) {
 		const candidatePath = `${path}.${index}`;
@@ -392,16 +468,16 @@ function validateSelectMany(
 			);
 			continue;
 		}
-		if (!choices.has(candidate)) {
+		if (!options.has(candidate)) {
 			issues.push(
 				issue(
-					"invalid_choice",
+					"invalid_option",
 					candidatePath,
 					translate(
 						i18n,
-						"errors:allowedChoice",
+						"errors:allowedOption",
 						{ label: localizedFieldLabel(field, i18n) },
-						`${localizedFieldLabel(field, i18n)} is not an allowed choice`
+						`${localizedFieldLabel(field, i18n)} is not an allowed option`
 					)
 				)
 			);
@@ -409,13 +485,13 @@ function validateSelectMany(
 		if (seen.has(candidate)) {
 			issues.push(
 				issue(
-					"duplicate_choice",
+					"duplicate_option",
 					candidatePath,
 					translate(
 						i18n,
-						"errors:duplicateChoice",
+						"errors:duplicateOption",
 						{ label: localizedFieldLabel(field, i18n) },
-						`${localizedFieldLabel(field, i18n)} must not contain duplicate choices`
+						`${localizedFieldLabel(field, i18n)} must not contain duplicate options`
 					)
 				)
 			);
@@ -684,6 +760,37 @@ function validateBlocks(
 			)
 		);
 	}
+	const minRows = field.blocks.minRows ?? 0;
+	const maxRows = field.blocks.maxRows ?? 0;
+	if (value.length < minRows && !(field.required && value.length === 0)) {
+		issues.push(
+			issue(
+				"min_rows",
+				path,
+				translate(
+					i18n,
+					"errors:minRows",
+					{ label: localizedFieldLabel(field, i18n), count: minRows },
+					`${localizedFieldLabel(field, i18n)} must contain at least ${minRows} rows`
+				)
+			)
+		);
+	}
+	if (maxRows > 0 && value.length > maxRows) {
+		issues.push(
+			issue(
+				"max_rows",
+				path,
+				translate(
+					i18n,
+					"errors:maxRows",
+					{ label: localizedFieldLabel(field, i18n), count: maxRows },
+					`${localizedFieldLabel(field, i18n)} must contain no more than ${maxRows} rows`
+				)
+			)
+		);
+	}
+
 	for (const [index, row] of value.entries()) {
 		const rowPath = `${path}.${index}`;
 		if (!isRecord(row)) {
@@ -696,7 +803,9 @@ function validateBlocks(
 			);
 			continue;
 		}
-		const block = field.blocks.types.find((candidate) => candidate.key === row.blockType);
+		const block = resolveBlockTypes(field.blocks).find(
+			(candidate) => candidate.slug === row.blockType
+		);
 		if (block === undefined) {
 			issues.push(
 				issue(
@@ -748,3 +857,60 @@ function translate(
 function localizedFieldLabel(field: SchemaField, i18n?: AdminI18n) {
 	return i18n?.text(field.admin.label, field.admin.labelTranslations) ?? field.admin.label;
 }
+
+/** Unknown stored variants require schema recovery even if a UI edit removed the row. */
+export function unknownBlockIssues(
+	fields: readonly SchemaField[],
+	values: FormValues,
+	i18n?: AdminI18n,
+	prefix = ""
+): ValidationIssue[] {
+	const issues: ValidationIssue[] = [];
+	for (const field of fields) {
+		const value = values[field.name];
+		const path = joinPath(prefix, field.name);
+		if (field.type === "group" && isRecord(value))
+			issues.push(...unknownBlockIssues(field.nested?.fields ?? [], value, i18n, path));
+		if (field.type === "plugin") {
+			const embedded = embeddedOccurrences(field, value, path);
+			issues.push(...embedded.issues);
+			for (const occurrence of embedded.occurrences)
+				issues.push(
+					...unknownBlockIssues(occurrence.block.fields, occurrence.payload, i18n, occurrence.path)
+				);
+		}
+		if (!Array.isArray(value)) continue;
+		if (field.type === "array") {
+			value.forEach((row, index) => {
+				if (isRecord(row))
+					issues.push(
+						...unknownBlockIssues(field.nested?.fields ?? [], row, i18n, `${path}.${index}`)
+					);
+			});
+		} else if (field.type === "blocks") {
+			value.forEach((row, index) => {
+				const block = isRecord(row)
+					? resolveBlockTypes(field.blocks).find((candidate) => candidate.slug === row.blockType)
+					: undefined;
+				if (block === undefined)
+					issues.push(
+						issue(
+							"unknown_block_schema",
+							`${path}.${index}.blockType`,
+							translate(
+								i18n,
+								"errors:unknownBlockRecovery",
+								{},
+								"Restore the missing block schema or migrate the document before saving."
+							)
+						)
+					);
+				else
+					issues.push(
+						...unknownBlockIssues(block.fields, row as FormValues, i18n, `${path}.${index}`)
+					);
+			});
+		}
+	}
+	return issues;
+}

package/src/core/forms/live-validation.svelte.ts

@@ -0,0 +1,317 @@
+import type { AdminClient } from "@admin/core/api/admin-client";
+import type {
+	LiveValidationEnvelope,
+	LiveValidationRequest,
+	ValidationIssue,
+} from "@riducms/protocol";
+import type { FieldLiveValidation } from "@riducms/plugin";
+import type { FormController } from "@admin/core/forms/form-controller.svelte";
+import { indexFieldValues, correlateFormIssues } from "@admin/core/forms/form-issue-correlation";
+import { captureFieldOccurrence } from "@admin/core/forms/field-occurrence";
+
+export type LiveValidationTransport = (
+	input: LiveValidationRequest,
+	signal: AbortSignal
+) => Promise<LiveValidationEnvelope>;
+
+type Feedback = {
+	path: string;
+	status: FieldLiveValidation["status"];
+	issues: ValidationIssue[];
+};
+
+/** One form owns advisory requests; save issues never enter this state. */
+export class LiveValidationController {
+	#feedback = $state.raw<ReadonlyMap<string, Feedback>>(new Map());
+	#active = new Set<string>();
+	#unavailableInputs = new Map<
+		symbol,
+		{ resolve: () => string | undefined; value: string | undefined }
+	>();
+	#generation = 0;
+	#request?: AbortController;
+	#timer?: ReturnType<typeof setTimeout>;
+	#deadline?: ReturnType<typeof setTimeout>;
+	#transport?: LiveValidationTransport;
+
+	constructor(private form: FormController) {}
+
+	configure(transport: LiveValidationTransport) {
+		this.reset();
+		this.#transport = transport;
+	}
+
+	request(input: LiveValidationRequest, signal: AbortSignal) {
+		if (!this.#transport) throw new Error("Live validation is unavailable in this form.");
+		return this.#transport(input, signal);
+	}
+
+	get available() {
+		return this.#transport !== undefined;
+	}
+	get inputAvailable(): boolean {
+		return (
+			this.#unavailableInputs.size === 0 &&
+			this.form.enclosingLiveInputAvailable &&
+			serializableInput(this.form.values) &&
+			indexFieldValues(this.form.schemaFields, this.form.values).every(({ schema, value }) => {
+				if (schema?.type !== "text-list" && schema?.type !== "number-list") return true;
+				if (value === null || value === undefined) return true;
+				// Numeric list controls retain unfinished text in the form itself. No
+				// activated check may mistake that buffer for a usable typed Root value.
+				return (
+					Array.isArray(value) &&
+					Array.from(value).every((item) =>
+						schema.type === "text-list"
+							? typeof item === "string"
+							: typeof item === "number" && Number.isFinite(item)
+					)
+				);
+			})
+		);
+	}
+
+	/** A control's unfinished buffer is not its last successfully decoded value. */
+	inputUnavailable(path: string) {
+		let resolve: () => string | undefined;
+		try {
+			resolve = captureFieldOccurrence(this.form, path).resolve;
+		} catch {
+			return () => false;
+		}
+		const lease = Symbol("unfinished-input");
+		this.#unavailableInputs.set(lease, { resolve, value: JSON.stringify(this.form.get(path)) });
+		this.#schedule(path);
+		return () => this.#unavailableInputs.delete(lease);
+	}
+
+	get issues() {
+		return [...this.#feedback.values()].flatMap((state) => state.issues);
+	}
+
+	forField(path: string): FieldLiveValidation {
+		const status =
+			[...this.#feedback.values()].find((state) => state.path === path)?.status ?? "idle";
+		return { status, retry: () => this.flush(path) };
+	}
+
+	/** Any edit invalidates activated checks: their Go code can read any sibling/root value. */
+	changed(path?: string) {
+		for (const [lease, unavailable] of this.#unavailableInputs) {
+			const current = unavailable.resolve();
+			// An ancestor write can merely reorder a still-mounted unfinished control.
+			// Release only a removed occurrence or a real replacement of its value.
+			if (
+				current === undefined ||
+				path === current ||
+				JSON.stringify(this.form.get(current)) !== unavailable.value
+			)
+				this.#unavailableInputs.delete(lease);
+		}
+		this.#schedule(path);
+	}
+
+	#schedule(path?: string) {
+		if (!this.available || this.form.submitting || !this.form.editorScopeActive) return;
+		this.#cancel();
+		const locations = this.#locations();
+		const current = new Set(locations.map((location) => location.token));
+		this.#active = new Set([...this.#active].filter((token) => current.has(token)));
+		if (path !== undefined)
+			for (const location of locations)
+				if (related(path, location.path)) this.#active.add(location.token);
+		const status = this.inputAvailable ? "pending" : "skipped";
+		this.#feedback = new Map(
+			locations
+				.filter(({ token }) => this.#active.has(token))
+				.map(({ token, path }) => [token, { path, status, issues: [] }])
+		);
+		if (this.#active.size && status === "pending") this.#timer = setTimeout(() => this.#run(), 500);
+	}
+
+	flush(path: string) {
+		if (
+			[...this.#feedback.values()].some(
+				(state) =>
+					(state.status === "pending" || state.status === "failed") && related(state.path, path)
+			)
+		)
+			this.#run();
+	}
+
+	/** Saving cancels advisory work but retains activation for later user edits. */
+	suspend() {
+		this.#cancel();
+		this.#feedback = new Map();
+	}
+
+	reset() {
+		this.suspend();
+		this.#active.clear();
+		this.#unavailableInputs.clear();
+	}
+
+	/** Binding revocation can be discovered during a derived read. Abort synchronously. */
+	dispose() {
+		this.#cancel();
+		this.#active.clear();
+		const generation = this.#generation;
+		queueMicrotask(() => {
+			if (generation === this.#generation) this.#feedback = new Map();
+		});
+	}
+
+	#cancel() {
+		this.#generation += 1;
+		this.#request?.abort();
+		this.#request = undefined;
+		if (this.#timer !== undefined) clearTimeout(this.#timer);
+		this.#timer = undefined;
+		if (this.#deadline !== undefined) clearTimeout(this.#deadline);
+		this.#deadline = undefined;
+	}
+
+	#locations() {
+		return indexFieldValues(this.form.schemaFields, this.form.values).filter(
+			({ schema, path }) =>
+				schema?.liveValidation &&
+				!schema.admin.readOnly &&
+				this.form.includesLiveValidation(path, schema.path)
+		);
+	}
+
+	async #run() {
+		if (
+			!this.available ||
+			this.form.submitting ||
+			!this.form.editorScopeActive ||
+			!this.inputAvailable
+		)
+			return;
+		this.#cancel();
+		const generation = this.#generation;
+		const request = new AbortController();
+		this.#request = request;
+		const locations = this.#locations().filter(({ token }) => this.#active.has(token));
+		if (!locations.length) return;
+		this.#feedback = new Map(
+			locations.map(({ token, path }) => [token, { path, status: "pending", issues: [] }])
+		);
+		const current = () =>
+			generation === this.#generation &&
+			!request.signal.aborted &&
+			!this.form.submitting &&
+			this.form.editorScopeActive;
+		try {
+			const values = this.form.snapshot();
+			let data: LiveValidationRequest["data"];
+			try {
+				data = this.form.liveValidationData();
+			} catch {
+				// A malformed plugin envelope has no usable submitted representation yet.
+				this.#feedback = new Map(
+					[...this.#feedback].map(([token, state]) => [
+						token,
+						{ ...state, status: "skipped", issues: [] },
+					])
+				);
+				return;
+			}
+			// Keep every request within the server's bounded field count, including large forms.
+			for (let offset = 0; offset < locations.length; offset += 64) {
+				const batch = locations.slice(offset, offset + 64);
+				// Leave room above the server's five-second evaluation bound for transport.
+				this.#deadline = setTimeout(() => {
+					if (!current()) return;
+					this.#cancel();
+					this.#failPending();
+				}, 8_000);
+				const result = await this.request(
+					{
+						...(this.form.resource?.id === undefined ? {} : { id: this.form.resource.id }),
+						data,
+						fields: batch.map(({ path }) => path),
+					},
+					request.signal
+				);
+				if (!current()) return;
+				if (this.#deadline !== undefined) clearTimeout(this.#deadline);
+				this.#deadline = undefined;
+				const feedback = new Map(this.#feedback);
+				for (const location of batch) {
+					const evaluation = result.evaluations.find((item) => item.path === location.path);
+					// A missing evaluation cannot silently become a successful check.
+					feedback.set(location.token, {
+						path: location.path,
+						status: evaluation?.status ?? "failed",
+						issues:
+							evaluation === undefined
+								? []
+								: correlateFormIssues(
+										this.form.schemaFields,
+										values,
+										this.form.values,
+										evaluation.issues
+									),
+					});
+				}
+				this.#feedback = feedback;
+			}
+		} catch {
+			if (!current()) return;
+			this.#failPending();
+		} finally {
+			if (this.#request === request) {
+				this.#request = undefined;
+				if (this.#deadline !== undefined) clearTimeout(this.#deadline);
+				this.#deadline = undefined;
+			}
+		}
+	}
+
+	#failPending() {
+		this.#feedback = new Map(
+			[...this.#feedback].map(([token, state]) => [
+				token,
+				state.status === "pending" ? { ...state, status: "failed", issues: [] } : state,
+			])
+		);
+	}
+}
+
+function related(left: string, right: string) {
+	return left === right || left.startsWith(`${right}.`) || right.startsWith(`${left}.`);
+}
+
+/** JSON would coerce NaN/Infinity to null, incorrectly making malformed input look empty. */
+function serializableInput(value: unknown, seen = new Set<object>(), depth = 0): boolean {
+	if (depth > 100) return false;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (
+		value === null ||
+		value === undefined ||
+		typeof value === "string" ||
+		typeof value === "boolean"
+	)
+		return true;
+	if (typeof value !== "object" || seen.has(value)) return false;
+	seen.add(value);
+	const available = Object.values(value).every((child) =>
+		serializableInput(child, seen, depth + 1)
+	);
+	seen.delete(value);
+	return available;
+}
+
+/** Connect a document form to the same authenticated SDK used for its writes. */
+export function connectDocumentLiveValidation(form: FormController, client: AdminClient) {
+	form.configureLiveValidation((input, signal) => {
+		const resource = form.resource;
+		if (!resource) throw new Error("No document is open for live validation.");
+		const options = { signal, locale: form.contentLocale };
+		const { id: _id, ...globalInput } = input;
+		return resource.global
+			? client.globalLiveValidation(resource.collection, globalInput, options)
+			: client.collectionLiveValidation(resource.collection, input, options);
+	});
+}