fix(ui): ensure oneOf choices inherit type and properties for forms (#3508)

Problem:
The Kaoto form engine (uniforms via `@kaoto/forms`) relies on each choice in a `oneOf` JSON schema array having `type: 'object'` and its own `properties` structure. When a `oneOf` schema choice only defines constraints (e.g. `{"required": ["data"]}`) on properties defined in the parent object, the form engine cannot render an appropriate choice option for it, leading to visual bugs and empty form sections.

Solution:
Created a `normalizeOneOfChoices` utility that intercepts JSON schemas before they are handed to `KaotoForm`. When traversing the schema, if a `oneOf` choice contains constraints but no type/properties, it now implicitly assumes `type: 'object'` and inherits the corresponding property definitions (and titles) from the parent schema.

Fixes #3508

Author: QuantumBreakz

packages/ui/src/components/Visualization/Canvas/Form/CanvasFormBody.tsx

@@ -3,7 +3,7 @@ import { FunctionComponent, useCallback, useContext, useMemo, useRef } from 'rea
 
 import { IVisualizationNode } from '../../../../models';
 import { EntitiesContext } from '../../../../providers/entities.provider';
-import { setValue } from '../../../../utils';
+import { normalizeOneOfChoices, setValue } from '../../../../utils';
 import { UnknownNode } from '../../Custom/UnknownNode';
 import { customFieldsFactoryfactory } from './fields/custom-fields-factory';
 import { SuggestionRegistrar } from './suggestions/SuggestionsProvider';
@@ -15,7 +15,7 @@ interface CanvasFormTabsProps {
 export const CanvasFormBody: FunctionComponent<CanvasFormTabsProps> = ({ vizNode }) => {
   const entitiesContext = useContext(EntitiesContext);
   const omitFields = useRef(vizNode.getOmitFormFields() ?? []);
-  const schema = useMemo(() => vizNode.getNodeSchema(), [vizNode]);
+  const schema = useMemo(() => normalizeOneOfChoices(vizNode.getNodeSchema()), [vizNode]);
 
   const isUnknownComponent = useMemo(() => {
     return !isDefined(schema) || Object.keys(schema).length === 0;

packages/ui/src/utils/index.ts

@@ -23,3 +23,4 @@ export * from './set-value';
 export * from './update-kamelet-from-custom-schema';
 export * from './xml-comments';
 export * from './yaml-comments';
+export * from './normalize-oneof-choices';

packages/ui/src/utils/normalize-oneof-choices.test.ts

@@ -0,0 +1,56 @@
+import { normalizeOneOfChoices } from './normalize-oneof-choices';
+
+describe('normalizeOneOfChoices', () => {
+  it('should not throw on primitives or null', () => {
+    expect(normalizeOneOfChoices(null)).toBeNull();
+    expect(normalizeOneOfChoices(undefined)).toBeUndefined();
+    expect(normalizeOneOfChoices('string')).toBe('string');
+  });
+
+  it('should normalize oneOf choices missing properties or type', () => {
+    const schema = {
+      type: 'object',
+      properties: {
+        data: {
+          type: 'string',
+          title: 'Data',
+        },
+        resource: {
+          type: 'string',
+          title: 'Resource',
+        },
+      },
+      anyOf: [
+        {
+          oneOf: [
+            { required: ['data'] },
+            {
+              type: 'object',
+              properties: {
+                resource: {
+                  type: 'object',
+                },
+              },
+            },
+          ],
+        },
+      ],
+    };
+
+    const normalized = normalizeOneOfChoices(schema);
+
+    // The first oneOf choice should have type 'object' and inherited properties
+    const choice1 = normalized.anyOf[0].oneOf[0];
+    expect(choice1.type).toBe('object');
+    expect(choice1.properties).toBeDefined();
+    expect(choice1.properties.data).toBeDefined();
+    expect(choice1.properties.data.type).toBe('string');
+    expect(choice1.properties.data.title).toBe('Data');
+    expect(choice1.title).toBe('Data'); // Inherited title
+
+    // The second choice should remain untouched
+    const choice2 = normalized.anyOf[0].oneOf[1];
+    expect(choice2.type).toBe('object');
+    expect(choice2.properties.resource.type).toBe('object');
+  });
+});

packages/ui/src/utils/normalize-oneof-choices.ts

@@ -0,0 +1,63 @@
+import cloneDeep from 'lodash/cloneDeep';
+
+export function normalizeOneOfChoices(schemaRaw: any, parentProperties?: any) {
+  if (!schemaRaw || typeof schemaRaw !== 'object') {
+    return schemaRaw;
+  }
+
+  const schema = parentProperties === undefined ? cloneDeep(schemaRaw) : schemaRaw;
+
+  let currentProperties = parentProperties;
+  if (schema.properties) {
+    currentProperties = schema.properties;
+  }
+
+  if (Array.isArray(schema.oneOf)) {
+    schema.oneOf.forEach((choice: any) => {
+      if (typeof choice === 'object' && choice !== null) {
+        if (!choice.type && !choice.$ref) {
+          // If it has 'required' or 'properties', or 'not', assume it's an object
+          if (choice.required || choice.properties || choice.not) {
+            if (!choice.not) {
+              choice.type = 'object';
+            }
+            // If it has 'required' but no 'properties', copy from parent
+            if (choice.required && !choice.properties && currentProperties) {
+              choice.properties = {};
+              for (const req of choice.required) {
+                if (currentProperties[req]) {
+                  choice.properties[req] = currentProperties[req];
+                  if (!choice.title && currentProperties[req].title) {
+                    choice.title = currentProperties[req].title;
+                  }
+                }
+              }
+              // If title is still missing and there's exactly one required property, use the required property name as title
+              if (!choice.title && choice.required.length === 1) {
+                choice.title = choice.required[0];
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+
+  // Recursively process children
+  for (const key of Object.keys(schema)) {
+    // We do not pass down `currentProperties` unconditionally because 
+    // properties of parent are only valid for that specific level.
+    // However, properties of schema.properties.x are for the next level.
+    if (key === 'properties') {
+      Object.values(schema.properties).forEach((item: any) => normalizeOneOfChoices(item, undefined));
+    } else if (key === 'oneOf' || key === 'anyOf' || key === 'allOf') {
+      schema[key].forEach((item: any) => normalizeOneOfChoices(item, currentProperties));
+    } else if (typeof schema[key] === 'object' && schema[key] !== null) {
+      // Don't pass parent properties into completely different structures like 'items' etc.
+      // unless it's inside anyOf/oneOf/allOf.
+      normalizeOneOfChoices(schema[key], undefined);
+    }
+  }
+
+  return schema;
+}