feat(console): mark immutable resource fields as read-only in edit forms

[lexfrei]

Summary

Resource fields declared immutable in the schema via x-kubernetes-validations: [{rule: "self == oldSelf"}] are now:

• Rendered grey-out with the helper text "This field cannot be changed after creation." on edit screens.
• Overlaid with the persisted value before PUT so the admission server observes no delta on those paths and the CEL rule is never tripped — defence-in-depth against the YAML editor, devtools, or RJSF bugs bypassing the read-only state.

Create flows are untouched.

Acceptance criterion

The companion cozystack/cozystack#2639 marks MariaDB storageClass immutable (itself dependent on cozystack/cozyvalues-gen#24). With all three PRs in place, opening an existing MariaDB instance for edit grays out storageClass, shows the helper text, keeps the rest editable, and the outgoing PUT carries the original storageClass value.

What's in this PR

• New helpers in apps/console/src/lib/immutable-paths.ts: findImmutablePaths walks the schema tree and returns every path carrying the CEL rule. overlayImmutable copies the original spec's values along those paths into the submitted body. Wildcard semantics: whole-array/whole-map (*-last) → clone from source; per-element nested (*-not-last) → overlay shared indices/keys, keep user adds, respect deletes. Length shrink with a nested-immutable path bails out with a console.warn (admission stays authoritative). Top-level wildcard paths are handled like root-immutable: warn + clone source.
• apps/console/src/lib/prepare-update.ts — pure wrapper; warns on malformed schema; short-circuits to a clone when persisted spec is null/undefined.
• SchemaForm accepts immutableMode (enforce | off, default off). When enforcing, walks the schema and emits ui:disabled + ui:help per immutable path. For object maps (additionalProperties) the field itself is marked disabled — per-entry-value semantics is deliberately deferred.
• sanitizeSchema strips x-kubernetes-validations once it has been harvested. AJV has no CEL evaluator, so the rule is pure noise to the form validator.
• ApplicationOrderPage and BackupResourceEditPage opt in to enforcement on edit and anchor the overlay source to a mount-time snapshot so a background React-Query refetch can't sneak a different immutable value into the PUT.

Known limitations (pinned with FIXME tests + tracking issues)

• immutable-paths: walker should descend into oneOf/anyOf/allOf branch properties #8 — walker does not recurse into properties beneath oneOf/anyOf/allOf branches.
• immutable-paths: overlay does not materialise an immutable leaf when its ancestor is missing #9 — overlay does not materialise immutable leaves whose ancestor is missing in the submitted body.
• immutable-paths: array reorder re-anchors source values to new indices #10 — same-length array reorder with a per-element-immutable field swaps source values onto the new indices. Different-length shrink is now bailed out with a warn.

Tests

The console workspace already had vitest + jsdom + @testing-library/react on main; this PR adds 7 new test files (immutable-paths walker, overlay edges, prepare-update, SchemaForm immutable rendering, AdditionalPropertiesField asymmetry, keys-order characterization) totalling 85 passing tests. pnpm test runs them all.

Tested manually against a hand-edited MariaDB values.schema.json carrying the rule on storageClass:

• Edit form: storageClass greyed out, helper text below, every other field editable.
• YAML editor bypass + Save → PUT body keeps the original storageClass value.
• Create flow: storageClass fully editable.
• Resources without the CEL rule: behaviour identical to master.

No-op until cozystack ships the schema annotation

When no schema carries the rule, findImmutablePaths returns [] everywhere, all walkers are no-ops, the overlay is identity, edit pages behave exactly as today. The UI lights up resource-by-resource as upstream annotates immutable fields.

[coderabbitai]

Important

Review skipped

Draft detected.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: 3a4f42f3-822a-41f2-8922-081d12eff9f2

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

• 🔍 Trigger review

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch claude/magical-meitner-7db476

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[gemini-code-assist]

Code Review

This pull request implements immutability enforcement in the SchemaForm component by parsing x-kubernetes-validations and applying ui:disabled and ui:help to immutable paths. It introduces a prepareUpdateSpec utility to ensure immutable values are preserved during updates and adds Vitest for testing. The review feedback highlights improvements for the array overlay logic to prevent potential null-value issues, suggests consolidating utility functions like isPlainObject and deepClone for better consistency, and recommends cleaning up redundant code in the update preparation logic.

[gemini-code-assist]

The current array overlay logic can produce arrays with undefined elements (holes) when the source array is longer than the target array (e.g., when an item is deleted). When serialized to JSON, these holes become null, which may violate the schema or cause unexpected behavior on the API server. Using targetArr.map is a safer and more concise way to handle positional overlays while correctly respecting deletions and additions.

    const sourceArr = Array.isArray(source) ? source : []
    const targetArr = Array.isArray(target) ? target : []
    return targetArr.map((item, i) =>
      i < sourceArr.length
        ? overlayPath(item, sourceArr[i], path, depth + 1)
        : deepClone(item),
    )

[gemini-code-assist]

Export isPlainObject so it can be reused in SchemaForm.tsx and deepClone for better consistency and code reuse.

Suggested change

	const isPlainObject = (v: unknown): v is Record<string, unknown> =>
	v !== null && typeof v === "object" && !Array.isArray(v)
	export const isPlainObject = (v: unknown): v is Record<string, unknown> =>
	v !== null && typeof v === "object" && !Array.isArray(v)

[gemini-code-assist]

Export deepClone to allow its reuse in prepare-update.ts, and use the isPlainObject helper for a cleaner and more consistent implementation.

Suggested change

	function deepClone<T>(value: T): T {
	if (value === null || value === undefined) return value
	if (Array.isArray(value)) return value.map(deepClone) as unknown as T
	if (typeof value === "object") {
	const out: Record<string, unknown> = {}
	for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
	out[k] = deepClone(v)
	}
	return out as unknown as T
	}
	return value
	}
	export function deepClone<T>(value: T): T {
	if (value === null || value === undefined) return value
	if (Array.isArray(value)) return value.map(deepClone) as unknown as T
	if (isPlainObject(value)) {
	const out: Record<string, unknown> = {}
	for (const [k, v] of Object.entries(value)) {
	out[k] = deepClone(v)
	}
	return out as unknown as T
	}
	return value
	}

[gemini-code-assist]

Add deepClone to the imports from ./immutable-paths.ts to replace the redundant cloneShallowAsDeep function.

Suggested change

	import {
	findImmutablePaths,
	overlayImmutable,
	type ImmutablePath,
	} from "./immutable-paths.ts"
	import {
	findImmutablePaths,
	overlayImmutable,
	deepClone,
	type ImmutablePath,
	} from "./immutable-paths.ts"

[gemini-code-assist]

Use the deepClone utility instead of cloneShallowAsDeep.

Suggested change

	return cloneShallowAsDeep(submitted)
	return deepClone(submitted)

[gemini-code-assist]

This function is redundant as deepClone is already implemented in immutable-paths.ts. Additionally, the name is misleading (it performs a deep clone) and the implementation using JSON.stringify is less efficient and can strip undefined values from objects.

[gemini-code-assist]

Add isPlainObject to the imports from ../lib/immutable-paths.ts.

Suggested change

	import {
	IMMUTABLE_HELP_TEXT,
	findImmutablePaths,
	type ImmutablePath,
	} from "../lib/immutable-paths.ts"
	import {
	IMMUTABLE_HELP_TEXT,
	findImmutablePaths,
	isPlainObject,
	type ImmutablePath,
	} from "../lib/immutable-paths.ts"

[gemini-code-assist]

Use the isPlainObject helper for better readability and consistency.

Suggested change

	if (existing && typeof existing === "object" && !Array.isArray(existing)) {
	if (isPlainObject(existing)) {