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 (properties, items, additionalProperties, oneOf/anyOf/allOf) and returns every path carrying the CEL rule. overlayImmutable copies the original spec's values along those paths into the submitted body. Wildcard semantics:
  • *-last with an array source: replace target with a clone of source (whole array immutable).
  • *-last with an object-map source: replace target with a clone of source (whole map immutable).
  • *-not-last with an array source: walk the user's array; restore the nested immutable subfield from source at shared indices, keep user-added entries verbatim, respect user deletions.
  • *-not-last with an object-map source: walk the user's keys; restore the nested immutable subfield from source at shared keys, keep user-added keys verbatim, respect user-deleted keys.
• apps/console/src/lib/prepare-update.ts — pure wrapper combining the two; logs a console warning when the schema fails to parse; short-circuits when the persisted spec is null/undefined to avoid blanking immutable fields with undefined.
• SchemaForm accepts an immutableMode prop ("enforce" | "off", default "off"). When enforcing, walks the schema and emits ui:disabled + ui:help per immutable path. Wildcard * maps to RJSF's items for arrays. For object maps (additionalProperties) the field itself is marked disabled — per-entry-value-immutable semantics is deliberately deferred until a real schema asks for it.
• sanitizeSchema strips x-kubernetes-validations once it has been harvested from the raw schema. AJV has no CEL evaluator, so the rule was pure noise.
• ApplicationOrderPage and BackupResourceEditPage opt in to enforcement on edit and call prepareUpdateSpec before mutating.

Known limitations (pinned with FIXME tests)

• The walker does not recurse into properties beneath oneOf/anyOf/allOf branches; it only treats the parent as immutable when any branch carries the rule itself.
• Overlay does not materialise immutable leaves whose ancestor is missing in the submitted body (e.g. YAML editor strips the parent object) — the leaf is silently dropped from the PUT.
• Overlay aligns array entries by index; if the user reorders an array with a per-element immutable field, source values follow indices rather than identities.

Each is covered by an explicit test pinning the current behaviour so a future contributor can iterate them.

Test infrastructure

vitest + jsdom + @testing-library/react are added as part of this PR. 53 unit and component tests cover the schema walker, sanitiser, submit overlay, and form behaviour (greyed inputs, helper text, array-items rendering, etc.). 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: 00b771c1-f740-4a36-9989-9e3d4807b44e

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)) {