@@ -119,6 +612,41 @@ export const ConfirmUpgradeResource: React.FunctionComponent
Upgrading the template version is irreversible.
+
+ {loadingSchema && }
+ {!loadingSchema && removedProperties.length > 0 && (
+
+ Warning: The following properties are no longer present in the template and will be removed:{" "}
+ {removedProperties.join(", ")}
+
+ )}
+ {!loadingSchema && allNewProperties.length > 0 && (
+
+ {newPropertiesToFill.length > 0 && (
+
+ Review values for new or changed properties:
+
+ )}
+
+ {finalSchema && (
+
+ )}
+
{
- option && setSelectedVersion(option.text);
+ if (option) {
+ setSelectedVersion(option.text);
+ setFormHasErrors(false);
+ }
}}
selectedKey={selectedVersion}
/>
- upgradeCall()} />
+ upgradeCall()} />
)}
{requestLoadingState === LoadingState.Loading && (
)}
- {requestLoadingState === LoadingState.Error && }
+ {requestLoadingState === LoadingState.Error && apiError && }
);
diff --git a/ui/app/src/components/shared/ResourceContextMenu.tsx b/ui/app/src/components/shared/ResourceContextMenu.tsx
index f8a06cc9b..292f06dd0 100644
--- a/ui/app/src/components/shared/ResourceContextMenu.tsx
+++ b/ui/app/src/components/shared/ResourceContextMenu.tsx
@@ -269,7 +269,18 @@ export const ResourceContextMenu: React.FunctionComponent setShowDelete(false)} resource={props.resource} />}
{showCopyUrl && setShowCopyUrl(false)} resource={props.resource} />}
- {showUpgrade && setShowUpgrade(false)} resource={props.resource} />}
+ {showUpgrade && (
+ setShowUpgrade(false)}
+ resource={props.resource}
+ parentWorkspaceService={
+ props.resource.resourceType === ResourceType.UserResource &&
+ (parentResource as WorkspaceService)?.templateName
+ ? (parentResource as WorkspaceService)
+ : undefined
+ }
+ />
+ )}
);
};
diff --git a/ui/app/src/utils/schemaUpgradeUtils.test.ts b/ui/app/src/utils/schemaUpgradeUtils.test.ts
new file mode 100644
index 000000000..d651c1820
--- /dev/null
+++ b/ui/app/src/utils/schemaUpgradeUtils.test.ts
@@ -0,0 +1,154 @@
+import { describe, expect, it } from "vitest";
+import {
+ extractConditionalBlocks,
+ getAllPropertyKeysFromTemplate,
+ getSchemaProperty,
+ isKeyActiveInTemplate,
+ isPropertyRequiredInState,
+ pruneSchemaNode,
+ setNestedValue,
+} from "./schemaUpgradeUtils";
+
+describe("schema upgrade utilities", () => {
+ it("evaluates required properties in the matching allOf branch", () => {
+ const schema = {
+ properties: {
+ mode: { type: "string" },
+ conditional_property: { type: "string" },
+ },
+ allOf: [
+ {
+ if: { properties: { mode: { const: "then" } } },
+ then: { required: ["conditional_property"] },
+ else: { required: ["mode"] },
+ },
+ ],
+ };
+
+ expect(isPropertyRequiredInState(schema, "conditional_property", { mode: "then" })).toBe(true);
+ expect(isPropertyRequiredInState(schema, "conditional_property", { mode: "else" })).toBe(false);
+ expect(isPropertyRequiredInState(schema, "mode", { mode: "else" })).toBe(true);
+ });
+
+ it("prunes nested properties and required fields", () => {
+ const schema = {
+ type: "object",
+ properties: {
+ parent: {
+ type: "object",
+ properties: {
+ kept: { type: "string" },
+ removed: { type: "string" },
+ },
+ required: ["kept", "removed"],
+ },
+ removed_top_level: { type: "string" },
+ },
+ required: ["parent", "removed_top_level"],
+ };
+
+ expect(pruneSchemaNode(schema, ["parent.kept"])).toEqual({
+ type: "object",
+ properties: {
+ parent: {
+ type: "object",
+ properties: { kept: { type: "string" } },
+ required: ["kept"],
+ },
+ },
+ required: ["parent"],
+ });
+ });
+
+ it("does not extract conditionals when a new key is only declared in a branch", () => {
+ const conditional = {
+ if: { properties: { selector: { const: "enabled" } } },
+ then: { required: ["new_property"] },
+ };
+ const schema = { allOf: [conditional] };
+
+ expect(extractConditionalBlocks(schema, ["new_property"])).toEqual({ allOf: [] });
+ });
+
+ it("keeps only target schema fields when cloning an upgrade array", () => {
+ const result: Record = {};
+ const formData = { items: [{ old_field: "removed", new_field: "kept" }] };
+ const targetSchema = {
+ properties: {
+ items: {
+ type: "array",
+ items: { type: "object", properties: { new_field: { type: "string" } } },
+ },
+ },
+ };
+
+ setNestedValue(result, "items.0.new_field", "kept", formData, targetSchema);
+
+ expect(result).toEqual({ items: [{ new_field: "kept" }] });
+ });
+
+ it("discovers properties in nested conditional branches", () => {
+ const schema = {
+ properties: {
+ parent: {
+ type: "object",
+ properties: { selector: { type: "string" } },
+ allOf: [
+ {
+ if: { properties: { selector: { const: "enabled" } } },
+ then: { properties: { conditional: { type: "string" } } },
+ },
+ ],
+ },
+ },
+ };
+
+ expect(getAllPropertyKeysFromTemplate(schema)).toContain("parent.conditional");
+ });
+
+ it("resolves nested conditional properties and active branches", () => {
+ const schema = {
+ properties: {
+ parent: {
+ type: "object",
+ properties: { selector: { type: "string" } },
+ allOf: [
+ {
+ if: { properties: { selector: { const: "enabled" } } },
+ then: { properties: { conditional: { type: "string" } } },
+ else: { properties: { other: { type: "string" } } },
+ },
+ ],
+ },
+ },
+ };
+
+ expect(getSchemaProperty(schema, "parent.conditional")).toEqual({ type: "string" });
+ expect(isKeyActiveInTemplate(schema, "parent.conditional", { parent: { selector: "enabled" } })).toBe(true);
+ expect(isKeyActiveInTemplate(schema, "parent.conditional", { parent: { selector: "disabled" } })).toBe(false);
+ });
+
+ it("recursively filters nested array item values by the target schema", () => {
+ const result: Record = {};
+ const formData = {
+ items: [{ nested: { kept: "yes", removed: "no" }, removed: "no" }],
+ };
+ const targetSchema = {
+ properties: {
+ items: {
+ type: "array",
+ items: {
+ type: "object",
+ properties: {
+ nested: { type: "object", properties: { kept: { type: "string" } } },
+ },
+ },
+ },
+ },
+ };
+
+ setNestedValue(result, "items.0.nested.kept", "yes", formData, targetSchema);
+
+ expect(result).toEqual({ items: [{ nested: { kept: "yes" } }] });
+ });
+});
diff --git a/ui/app/src/utils/schemaUpgradeUtils.ts b/ui/app/src/utils/schemaUpgradeUtils.ts
new file mode 100644
index 000000000..1cec0b2b5
--- /dev/null
+++ b/ui/app/src/utils/schemaUpgradeUtils.ts
@@ -0,0 +1,460 @@
+/**
+ * Schema Upgrade Utility Functions
+ * Helper utilities for comparing JSON Schemas, resolving dotted paths,
+ * evaluating allOf conditions, and building reduced forms during resource upgrades.
+ */
+
+// Utility to check if a path part name is a prototype property
+export const partGuard = (part: string): boolean =>
+ part === "__proto__" || part === "constructor" || part === "prototype";
+
+export const clonePropertyValues = (value: T): T => {
+ if (typeof structuredClone === "function") {
+ return structuredClone(value);
+ }
+ return JSON.parse(JSON.stringify(value)) as T;
+};
+
+const getAllPropertyKeysFromSchemaNode = (schema: any, prefix = "", data: any = undefined): string[] => {
+ if (!schema || typeof schema !== "object") return [];
+ let keys = getAllPropertyKeys(schema.properties, prefix, data);
+ for (const condition of schema.allOf ?? []) {
+ keys = keys.concat(getAllPropertyKeysFromSchemaNode(condition?.then, prefix, data));
+ keys = keys.concat(getAllPropertyKeysFromSchemaNode(condition?.else, prefix, data));
+ }
+ return keys;
+};
+
+// Utility to get all property keys from template schema's properties object recursively, flattening nested if needed
+export const getAllPropertyKeys = (properties: any, prefix = "", data: any = undefined): string[] => {
+ if (!properties) return [];
+ let keys: string[] = [];
+ for (const [key, value] of Object.entries(properties)) {
+ if (partGuard(key)) continue;
+ const currentData = data && typeof data === "object" ? data[key] : undefined;
+ if (value && typeof value === "object" && (value as any).items && typeof (value as any).items === "object") {
+ keys.push(prefix + key);
+ if (Array.isArray(currentData) && (value as any).items.properties) {
+ currentData.forEach((_item: any, index: number) => {
+ keys = keys.concat(
+ getAllPropertyKeysFromSchemaNode((value as any).items, `${prefix + key}.${index}.`, _item),
+ );
+ });
+ }
+ } else if (value && typeof value === "object" && "properties" in value) {
+ // Include the object container itself so required-object detection works, then recurse into children.
+ // Array item properties are traversed with indexed paths such as "items.0.value".
+ keys.push(prefix + key);
+ keys = keys.concat(getAllPropertyKeysFromSchemaNode(value, prefix + key + ".", currentData));
+ } else {
+ keys.push(prefix + key);
+ }
+ }
+ return keys;
+};
+
+// Utility to get a nested value from an object using a dotted path (e.g. "parent.child")
+export const getNestedValue = (obj: any, path: string): any => {
+ const parts = path.split(".");
+ let current = obj;
+ for (const part of parts) {
+ if (partGuard(part)) {
+ return undefined;
+ }
+ if (current === null || current === undefined) return undefined;
+ current = current[part];
+ }
+ return current;
+};
+
+// Utility to set a nested value in an object using a dotted path (e.g. "parent.sibling")
+const cloneValueForSchema = (value: any, schema: any): any => {
+ if (Array.isArray(value)) return value.map((item) => cloneValueForSchema(item, schema?.items));
+ if (!value || typeof value !== "object" || !schema?.properties) return clonePropertyValues(value);
+ const result: Record = {};
+ for (const key of Object.keys(schema.properties)) {
+ if (partGuard(key) || value[key] === undefined) continue;
+ result[key] = cloneValueForSchema(value[key], schema.properties[key]);
+ }
+ return result;
+};
+
+const cloneArrayValuesForSchema = (value: any[], schema: any): any[] => cloneValueForSchema(value, schema);
+
+export const setNestedValue = (obj: any, path: string, value: any, source?: any, sourceSchema?: any): void => {
+ const parts = path.split(".");
+ let current = obj;
+ let currentSource = source;
+ let currentSchema = sourceSchema;
+ for (let i = 0; i < parts.length - 1; i++) {
+ const part = parts[i];
+ if (partGuard(part)) {
+ return;
+ }
+ const sourceValue = currentSource && typeof currentSource === "object" ? currentSource[part] : undefined;
+ if (!(part in current) || typeof current[part] !== "object" || current[part] === null) {
+ current[part] = Array.isArray(sourceValue)
+ ? cloneArrayValuesForSchema(sourceValue, currentSchema?.properties?.[part] ?? currentSchema?.items)
+ : {};
+ }
+ current = current[part];
+ currentSource = sourceValue;
+ currentSchema = currentSchema?.properties?.[part] ?? currentSchema?.items;
+ }
+ const lastPart = parts[parts.length - 1];
+ if (!partGuard(lastPart)) {
+ current[lastPart] = value;
+ }
+};
+
+// Utility to deeply merge two property objects (e.g. existing resource properties and new property values)
+export const mergePropertyValues = (existing: any, updated: any): any => {
+ if (!existing || typeof existing !== "object") return updated || {};
+ if (!updated || typeof updated !== "object") return existing || {};
+ const result: any = { ...existing };
+ for (const key of Object.keys(updated)) {
+ if (partGuard(key)) continue;
+ if (
+ updated[key] &&
+ typeof updated[key] === "object" &&
+ !Array.isArray(updated[key]) &&
+ existing[key] &&
+ typeof existing[key] === "object" &&
+ !Array.isArray(existing[key])
+ ) {
+ result[key] = mergePropertyValues(existing[key], updated[key]);
+ } else {
+ result[key] = updated[key];
+ }
+ }
+ return result;
+};
+
+// Utility to get schema property from properties object using a dotted path
+export const getSchemaPropertyFromProperties = (properties: any, path: string): any => {
+ const parts = path.split(".");
+ let current = properties;
+ for (let i = 0; i < parts.length; i++) {
+ const part = parts[i];
+ if (partGuard(part)) {
+ return null;
+ }
+ if (/^\d+$/.test(part)) {
+ continue;
+ }
+ if (!current || !current[part]) return null;
+ if (i === parts.length - 1) {
+ return current[part];
+ }
+ if (current[part].items && /^\d+$/.test(parts[i + 1])) {
+ current = current[part].items.properties || current[part].items;
+ } else if (current[part].properties) {
+ current = current[part].properties;
+ } else {
+ return null;
+ }
+ }
+ return null;
+};
+
+// Utility to get schema property from template (both properties and allOf) using a dotted path
+export const getSchemaProperty = (template: any, path: string): any => {
+ const find = (schema: any, parts: string[]): any => {
+ if (!schema || parts.length === 0) return null;
+ const [part, ...remainingParts] = parts;
+ if (!partGuard(part) && !/^\d+$/.test(part) && schema.properties?.[part]) {
+ const property = schema.properties[part];
+ return remainingParts.length === 0 ? property : find(property, remainingParts);
+ }
+ if (/^\d+$/.test(part) && schema.items) return find(schema.items, remainingParts);
+ for (const condition of schema.allOf ?? []) {
+ const result = find(condition?.then, parts) || find(condition?.else, parts);
+ if (result) return result;
+ }
+ return null;
+ };
+ return find(template, path.split("."));
+};
+
+// Utility to get nested uiSchema object using a dotted path
+export const getNestedUiSchema = (uiSchema: any, path: string): any => {
+ const parts = path.split(".");
+ let current = uiSchema;
+ for (const part of parts) {
+ if (partGuard(part)) {
+ return undefined;
+ }
+ if (current === null || current === undefined) return undefined;
+ current = current[part];
+ }
+ return current;
+};
+
+// Utility to check if a simple JSON Schema condition matches the current state
+export const matchesIfCondition = (ifSchema: any, state: any): boolean => {
+ if (!ifSchema || !ifSchema.properties) return false;
+ for (const [key, cond] of Object.entries(ifSchema.properties)) {
+ const val = getNestedValue(state, key);
+ if (cond && typeof cond === "object") {
+ if ("const" in (cond as any)) {
+ if (val !== (cond as any).const) return false;
+ } else if ("enum" in (cond as any) && Array.isArray((cond as any).enum)) {
+ if (!(cond as any).enum.includes(val)) return false;
+ } else {
+ // treat only undefined/null as missing; allow false, 0, and empty string as valid values
+ if (val === undefined || val === null) return false;
+ }
+ } else {
+ // treat only undefined/null as missing; allow false, 0, and empty string as valid values
+ if (val === undefined || val === null) return false;
+ }
+ }
+ return true;
+};
+
+// Utility to check if a nested property (dotted path) is required in the schema given the current form state
+export const isPropertyRequiredInState = (templateSchema: any, path: string, state: any): boolean => {
+ if (!templateSchema) return false;
+
+ const parts = path.split(".");
+ let currentSchema = templateSchema;
+ let currState = state;
+
+ for (let i = 0; i < parts.length; i++) {
+ const part = parts[i];
+ if (!currentSchema) return false;
+
+ if (/^\d+$/.test(part) && currentSchema.items) {
+ currentSchema = currentSchema.items;
+ currState = currState ? currState[part] : undefined;
+ continue;
+ }
+
+ let isPartRequired = currentSchema.required && currentSchema.required.includes(part);
+
+ if (currentSchema.allOf) {
+ for (const condition of currentSchema.allOf) {
+ if (matchesIfCondition(condition.if, currState)) {
+ if (condition.then && condition.then.required && condition.then.required.includes(part)) {
+ isPartRequired = true;
+ }
+ } else {
+ if (condition.else && condition.else.required && condition.else.required.includes(part)) {
+ isPartRequired = true;
+ }
+ }
+ }
+ }
+
+ if (i === parts.length - 1) {
+ return !!isPartRequired;
+ }
+
+ const isPartPresent = currState && currState[part] !== undefined && currState[part] !== null;
+ if (!isPartRequired && !isPartPresent) {
+ return false;
+ }
+
+ let nextSchema = currentSchema.properties ? currentSchema.properties[part] : undefined;
+ if (!nextSchema && currentSchema.allOf) {
+ for (const condition of currentSchema.allOf) {
+ const branch = matchesIfCondition(condition.if, currState) ? condition.then : condition.else;
+ if (branch?.properties?.[part]) {
+ nextSchema = branch.properties[part];
+ break;
+ }
+ }
+ }
+ currentSchema = nextSchema;
+ currState = currState ? currState[part] : undefined;
+ }
+ return false;
+};
+
+/**
+ * Recursively prunes an object schema node to only include properties
+ * that match or are prefixes of active property keys.
+ */
+export const pruneSchemaNode = (schemaNode: any, activeKeys: string[]): any => {
+ if (!schemaNode || typeof schemaNode !== "object") {
+ return schemaNode;
+ }
+
+ if (!schemaNode.properties || typeof schemaNode.properties !== "object") {
+ return { ...schemaNode };
+ }
+
+ const prunedProperties: Record = Object.create(null);
+ const prunedRequired: string[] = [];
+ const activeKeySet = new Set(activeKeys);
+ const matchingSubKeysByProperty = new Map();
+
+ for (const activeKey of activeKeys) {
+ const separatorIndex = activeKey.indexOf(".");
+ if (separatorIndex === -1) continue;
+
+ const propName = activeKey.slice(0, separatorIndex);
+ const subKey = activeKey.slice(separatorIndex + 1);
+ const matchingSubKeys = matchingSubKeysByProperty.get(propName) ?? [];
+ matchingSubKeys.push(subKey);
+ matchingSubKeysByProperty.set(propName, matchingSubKeys);
+ }
+
+ for (const [propName, propSchema] of Object.entries(schemaNode.properties)) {
+ if (partGuard(propName)) continue;
+
+ const exactMatch = activeKeySet.has(propName);
+ const matchingSubKeys = matchingSubKeysByProperty.get(propName) ?? [];
+
+ if (exactMatch || matchingSubKeys.length > 0) {
+ if (
+ matchingSubKeys.length > 0 &&
+ propSchema &&
+ typeof propSchema === "object" &&
+ (propSchema as any).items?.properties
+ ) {
+ const itemKeys = matchingSubKeys.filter((key) => /^\d+\./.test(key)).map((key) => key.replace(/^\d+\./, ""));
+ prunedProperties[propName] = {
+ ...(propSchema as any),
+ items: pruneSchemaNode((propSchema as any).items, itemKeys),
+ };
+ } else if (
+ matchingSubKeys.length > 0 &&
+ propSchema &&
+ typeof propSchema === "object" &&
+ (propSchema as any).properties
+ ) {
+ prunedProperties[propName] = pruneSchemaNode(propSchema, matchingSubKeys);
+ } else {
+ prunedProperties[propName] = { ...(propSchema as any) };
+ }
+
+ if (Array.isArray(schemaNode.required) && schemaNode.required.includes(propName)) {
+ prunedRequired.push(propName);
+ }
+ }
+ }
+
+ const result: any = {
+ ...schemaNode,
+ properties: prunedProperties,
+ };
+
+ if (prunedRequired.length > 0) {
+ result.required = prunedRequired;
+ } else {
+ delete result.required;
+ }
+
+ return result;
+};
+
+// Utility to build a reduced schema with only given keys, recursively pruning object schemas
+export const buildReducedSchema = (fullSchema: any, keys: string[]): any => {
+ if (!fullSchema || !fullSchema.properties) return null;
+ return pruneSchemaNode(fullSchema, keys);
+};
+
+// Utility to collect direct property keys referenced inside conditional schemas
+export const collectConditionalKeys = (entry: any): string[] => {
+ const keys: string[] = [];
+ if (!entry) return keys;
+ const collect = (schemaPart: any) => {
+ if (!schemaPart) return;
+ // collect any property names declared under a properties block
+ if (schemaPart.properties) {
+ keys.push(...Object.keys(schemaPart.properties));
+ }
+ // also collect any property names declared as required (common pattern where
+ // a conditional only sets then.required / else.required without redefining
+ // the property's schema under then/else.properties)
+ if (Array.isArray(schemaPart.required)) {
+ keys.push(...schemaPart.required.filter((r: unknown): r is string => typeof r === "string"));
+ }
+ };
+ collect(entry.if);
+ return [...new Set(keys)];
+};
+
+// Extract conditional blocks that reference any of the new properties.
+export const extractConditionalBlocks = (schema: any, newKeys: string[]) => {
+ const conditionalEntries: any[] = [];
+ if (!schema) return { allOf: [] };
+ const allOf = schema.allOf || [];
+ // precompute top-level names for the new keys
+ const newTopKeys = new Set(newKeys.map((nk) => (typeof nk === "string" ? nk.split(".")[0] : nk)));
+ allOf.forEach((entry: any) => {
+ if (entry && entry.if) {
+ const conditionalKeys = collectConditionalKeys(entry);
+ const conditionalTopKeys = conditionalKeys.map((k) => (typeof k === "string" ? k.split(".")[0] : k));
+ // include entry if any top-level conditional key matches a top-level new key
+ if (conditionalTopKeys.some((ck) => newTopKeys.has(ck))) {
+ conditionalEntries.push(entry);
+ }
+ }
+ });
+ return { allOf: conditionalEntries };
+};
+
+// Helper to extract all property keys from template properties and allOf conditionals
+export const getAllPropertyKeysFromTemplate = (template: any, data: any = undefined): string[] => {
+ if (!template) return [];
+ return [...new Set(getAllPropertyKeysFromSchemaNode(template, "", data))];
+};
+
+// Include properties from branches controlled by any of the supplied keys so a selector change can activate them.
+export const getConditionalPropertyKeysForTriggers = (template: any, triggerKeys: string[]): string[] => {
+ if (!template?.allOf || triggerKeys.length === 0) return [];
+
+ const triggerTopKeys = new Set(triggerKeys.map((key) => key.split(".")[0]));
+ const dependentKeys: string[] = [];
+
+ template.allOf.forEach((condition: any) => {
+ const conditionalKeys = collectConditionalKeys(condition);
+ if (!conditionalKeys.some((key) => triggerTopKeys.has(key.split(".")[0]))) return;
+
+ if (condition.then?.properties) {
+ dependentKeys.push(...getAllPropertyKeys(condition.then.properties));
+ }
+ if (condition.else?.properties) {
+ dependentKeys.push(...getAllPropertyKeys(condition.else.properties));
+ }
+ });
+
+ return [...new Set(dependentKeys)];
+};
+
+// Helper to extract top-level keys (matching backend removal checks)
+export const getTopLevelKeysFromTemplate = (template: any): string[] => {
+ if (!template) return [];
+ let keys = Object.keys(template.properties || {}).filter((k) => !partGuard(k));
+ if (template.allOf) {
+ template.allOf.forEach((condition: any) => {
+ if (condition.then && condition.then.properties) {
+ keys = keys.concat(Object.keys(condition.then.properties).filter((k) => !partGuard(k)));
+ }
+ if (condition.else && condition.else.properties) {
+ keys = keys.concat(Object.keys(condition.else.properties).filter((k) => !partGuard(k)));
+ }
+ });
+ }
+ return [...new Set(keys)];
+};
+
+// Helper to determine if a property key is defined on an active branch of the template for the given state
+export const isKeyActiveInTemplate = (template: any, path: string, state: any): boolean => {
+ const find = (schema: any, parts: string[], currentState: any): boolean => {
+ if (!schema || parts.length === 0) return false;
+ const [part, ...remainingParts] = parts;
+ if (!partGuard(part) && !/^\d+$/.test(part) && schema.properties?.[part]) {
+ return remainingParts.length === 0 || find(schema.properties[part], remainingParts, currentState?.[part]);
+ }
+ if (/^\d+$/.test(part) && schema.items) return find(schema.items, remainingParts, currentState?.[Number(part)]);
+ for (const condition of schema.allOf ?? []) {
+ const branch = matchesIfCondition(condition?.if, currentState) ? condition?.then : condition?.else;
+ if (find(branch, parts, currentState)) return true;
+ }
+ return false;
+ };
+ return find(template, path.split("."), state);
+};