fix(orchestrator): honor json schema defaults in initial formData (#2654)

* fix(orchestrator): honor json schema defaults

Ensure extractStaticDefaults falls back to JSON Schema defaults when ui:props fetch:response:default is absent so initial formData includes schema defaults.

Made-with: Cursor

* chore(changeset): document schema default fix

Add changeset for orchestrator form defaults update.

Made-with: Cursor

* fix(orchestrator): handle root defaults

Avoid setting an empty key for root schema defaults and add tests to cover root default handling.

Made-with: Cursor

* fix(orchestrator): document and test defaults

Clarify extractStaticDefaults precedence in docs and add test coverage for default handling.

Made-with: Cursor

Author: lokanandaprabhu

workspaces/orchestrator/.changeset/honor-schema-defaults.md

@@ -0,0 +1,6 @@
+---
+'@red-hat-developer-hub/backstage-plugin-orchestrator-form-react': patch
+---
+
+Include JSON Schema `default` values when computing initial form data so
+template expressions can resolve defaults before widgets render.

workspaces/orchestrator/plugins/orchestrator-form-react/src/utils/extractStaticDefaults.test.ts

@@ -0,0 +1,119 @@
+/*
+ * Copyright Red Hat, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { JSONSchema7 } from 'json-schema';
+
+import extractStaticDefaults from './extractStaticDefaults';
+
+describe('extractStaticDefaults', () => {
+  it('applies schema defaults when no fetch default', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      properties: {
+        name: { type: 'string', default: 'app' },
+      },
+    };
+
+    expect(extractStaticDefaults(schema)).toEqual({ name: 'app' });
+  });
+
+  it('prefers fetch:response:default over schema default', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      properties: {
+        name: {
+          type: 'string',
+          default: 'schema',
+          'ui:props': { 'fetch:response:default': 'fetch' },
+        } as JSONSchema7 & Record<string, unknown>,
+      },
+    };
+
+    expect(extractStaticDefaults(schema)).toEqual({ name: 'fetch' });
+  });
+
+  it('does not overwrite existing form data values', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      properties: {
+        name: { type: 'string', default: 'schema' },
+      },
+    };
+
+    expect(extractStaticDefaults(schema, { name: 'existing' })).toEqual({
+      name: 'existing',
+    });
+  });
+
+  it('preserves falsy defaults', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      properties: {
+        enabled: { type: 'boolean', default: false },
+        retries: { type: 'number', default: 0 },
+        note: { type: 'string', default: '' },
+      },
+    };
+
+    expect(extractStaticDefaults(schema)).toEqual({
+      enabled: false,
+      retries: 0,
+      note: '',
+    });
+  });
+
+  it('applies defaults from composed schemas', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      allOf: [
+        {
+          type: 'object',
+          properties: {
+            name: { type: 'string', default: 'composed' },
+          },
+        },
+      ],
+    };
+
+    expect(extractStaticDefaults(schema)).toEqual({ name: 'composed' });
+  });
+
+  it('applies root default objects without creating empty key', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      default: { foo: 'bar' },
+      properties: {
+        foo: { type: 'string' },
+      },
+    };
+
+    expect(extractStaticDefaults(schema)).toEqual({ foo: 'bar' });
+  });
+
+  it('does not override existing data with root defaults', () => {
+    const schema: JSONSchema7 = {
+      type: 'object',
+      default: { foo: 'bar' },
+      properties: {
+        foo: { type: 'string' },
+      },
+    };
+
+    expect(extractStaticDefaults(schema, { foo: 'existing' })).toEqual({
+      foo: 'existing',
+    });
+  });
+});

workspaces/orchestrator/plugins/orchestrator-form-react/src/utils/extractStaticDefaults.ts

@@ -20,12 +20,19 @@ import type { JSONSchema7, JSONSchema7Definition } from 'json-schema';
 import get from 'lodash/get';
 import set from 'lodash/set';
 
+const isPlainObject = (value: unknown): value is JsonObject => {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+};
+
 /**
- * Extracts static default values from fetch:response:default properties in the schema.
+ * Extracts static default values from the schema in priority order:
+ * 1) ui:props.fetch:response:default
+ * 2) JSON Schema default
+ *
  * These values are applied to formData before widgets render, ensuring defaults
  * are available immediately without waiting for fetch operations.
  *
- * @param schema - The JSON Schema containing ui:props with fetch:response:default
+ * @param schema - The JSON Schema containing ui:props and/or default values
  * @param existingFormData - Existing form data to preserve (won't be overwritten)
  * @returns An object containing the extracted default values merged with existing data
  */
@@ -60,14 +67,26 @@ export function extractStaticDefaults(
 
     // Extract fetch:response:default from ui:props
     const uiProps = (curSchema as Record<string, unknown>)['ui:props'];
+    let staticDefault: unknown;
     if (uiProps && typeof uiProps === 'object') {
-      const staticDefault = (uiProps as Record<string, unknown>)[
+      staticDefault = (uiProps as Record<string, unknown>)[
         'fetch:response:default'
       ];
-      if (staticDefault !== undefined) {
-        // Only set if not already in existing form data
-        const existingValue = get(existingFormData, path);
-        if (existingValue === undefined || existingValue === null) {
+    }
+
+    if (staticDefault === undefined && 'default' in curSchema) {
+      staticDefault = (curSchema as JSONSchema7).default;
+    }
+
+    if (staticDefault !== undefined) {
+      // Only set if not already in existing form data
+      const existingValue = get(existingFormData, path);
+      if (existingValue === undefined || existingValue === null) {
+        if (path === '') {
+          if (isPlainObject(staticDefault)) {
+            Object.assign(defaults, staticDefault);
+          }
+        } else {
           set(defaults, path, staticDefault);
         }
       }