Fix(CanvasForm): Update model validation to support new complex schema

packages/catalog-generator/src/main/java/io/kaoto/camelcatalog/generators/CamelCatalogSchemaEnhancer.java

@@ -74,6 +74,7 @@ void fillRequiredPropertiesIfNeeded(BaseModel<? extends BaseOptionModel> model,
         modelOptions.forEach(option -> {
             if (option.isRequired() && modelNode.has("properties")
                     && modelNode.get("properties").has(option.getName())
+                    && !modelNode.get("properties").get(option.getName()).isEmpty()
                     && !requiredProperties.contains(option.getName())) {
                 requiredProperties.add(option.getName());
             }

packages/catalog-generator/src/test/java/io/kaoto/camelcatalog/generators/CamelCatalogSchemaEnhancerTest.java

@@ -77,14 +77,13 @@ void shouldFillRequiredPropertiesIfNeededForModelName() {
         camelCatalogSchemaEnhancer.fillRequiredPropertiesIfNeeded(Kind.eip, "setHeader", setHeaderNode);
 
         assertTrue(setHeaderNode.has("required"));
-        assertEquals(2, setHeaderNode.get("required").size());
+        assertEquals(1, setHeaderNode.get("required").size());
 
         List<String> requiredProperties = new ArrayList<>();
         setHeaderNode.withArray("required").elements()
                 .forEachRemaining(node -> requiredProperties.add(node.asText()));
 
         assertTrue(requiredProperties.contains("name"));
-        assertTrue(requiredProperties.contains("expression"));
     }
 
     @Test
@@ -101,14 +100,13 @@ void shouldFillRequiredPropertiesIfNeededForModel() {
         camelCatalogSchemaEnhancer.fillRequiredPropertiesIfNeeded(model, setHeaderNode);
 
         assertTrue(setHeaderNode.has("required"));
-        assertEquals(2, setHeaderNode.get("required").size());
+        assertEquals(1, setHeaderNode.get("required").size());
 
         List<String> requiredProperties = new ArrayList<>();
         setHeaderNode.withArray("required").elements()
                 .forEachRemaining(node -> requiredProperties.add(node.asText()));
 
         assertTrue(requiredProperties.contains("name"));
-        assertTrue(requiredProperties.contains("expression"));
     }
 
     @Test

packages/catalog-generator/src/test/java/io/kaoto/camelcatalog/generators/EIPGeneratorTest.java

@@ -137,7 +137,6 @@ void shouldFillRequiredPropertiesIfNeeded() {
                 .forEachRemaining(node -> requiredProperties.add(node.asText()));
 
         assertTrue(requiredProperties.contains("name"));
-        assertTrue(requiredProperties.contains("expression"));
 
         var deleteNode = processorsMap.get("delete");
 

packages/ui/src/components/Visualization/Canvas/FormV2/fields/AutoField.tsx

@@ -21,6 +21,7 @@ export const AutoField: FunctionComponent<FieldProps> = ({ propName, required, o
   const isFieldDefined = isDefined(value);
   const isComplexFieldType =
     schema.type === 'object' || schema.type === 'array' || 'oneOf' in schema || 'anyOf' in schema;
+  // If required is not defined, it is considered as required
   const isFieldRequired = !isDefined(required) || (isDefined(required) && required);
   const shouldLoadField = isFieldRequired || (isFieldDefined && isComplexFieldType);
 

packages/ui/src/models/visualization/flows/support/validators/model-validation.service.test.ts

@@ -22,6 +22,12 @@ describe('ModelValidationService', () => {
               parameters: {},
             },
           },
+          {
+            setHeader: {
+              id: 'test',
+              constant: {},
+            },
+          },
           {
             to: {
               description: 'azz',
@@ -54,15 +60,25 @@ describe('ModelValidationService', () => {
     });
 
     it('should return a validation text pointing to multiple missing properties', () => {
-      const model = camelRoute.route.from.steps[1].to;
-      const path = 'route.from.steps[1].to';
+      const model = camelRoute.route.from.steps[2].to;
+      const path = 'route.from.steps[2].to';
       const schema = CamelComponentSchemaService.getVisualComponentSchema(path, model);
 
       const result = ModelValidationService.validateNodeStatus(schema);
 
       expect(result).toEqual('2 required parameters are not yet configured: [ topic,bootstrapServers ]');
     });
 
+    it('should return a validation text for setheader pointing to multiple missing properties', () => {
+      const model = camelRoute.route.from.steps[1].setHeader;
+      const path = 'route.from.steps[1].setHeader';
+      const schema = CamelComponentSchemaService.getVisualComponentSchema(path, model);
+
+      const result = ModelValidationService.validateNodeStatus(schema);
+
+      expect(result).toEqual('2 required parameters are not yet configured: [ expression,name ]');
+    });
+
     it('should return an empty string if there is no missing property', () => {
       const model = { ...camelRoute.route.from.steps[0].to, parameters: { destinationName: 'myQueue' } };
       const path = 'route.from.steps[0].to';

packages/ui/src/models/visualization/flows/support/validators/model-validation.service.ts

@@ -1,3 +1,4 @@
+import { resolveSchemaWithRef } from '../../../../../utils/resolve-ref-if-needed';
 import { KaotoSchemaDefinition } from '../../../../kaoto-schema';
 import { VisualComponentSchema } from '../../../base-visual-entity';
 
@@ -28,7 +29,12 @@ export class ModelValidationService {
     if (!schema?.schema) return '';
     let message = '';
 
-    const validationResult = this.validateRequiredProperties(schema.schema, schema.definition, '');
+    const validationResult = this.validateRequiredProperties(
+      schema.schema,
+      schema.definition,
+      '',
+      schema.schema.definitions,
+    );
     const missingProperties = validationResult
       .filter((result) => result.type === 'missingRequired')
       .map((result) => result.propertyName);
@@ -48,18 +54,45 @@ export class ModelValidationService {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     model: any,
     parentPath: string,
+    definitions?: Record<string, KaotoSchemaDefinition['schema']>,
   ): IValidationResult[] {
     const answer = [] as IValidationResult[];
 
+    const resolvedSchema = schema;
+    if (Array.isArray(resolvedSchema.anyOf)) {
+      resolvedSchema.anyOf.map((anyOfSchema) =>
+        answer.push(...this.validateRequiredProperties(anyOfSchema, model, parentPath, definitions)),
+      );
+    }
+
+    if (Array.isArray(resolvedSchema.oneOf)) {
+      resolvedSchema.oneOf.map((oneOfSchema) =>
+        answer.push(...this.validateRequiredProperties(oneOfSchema, model, parentPath, definitions)),
+      );
+    }
+
+    if (!schema.properties && schema.$ref) {
+      // resolve the ref
+      const resolvedSchema = resolveSchemaWithRef(schema, definitions!);
+      answer.push(...this.validateRequiredProperties(resolvedSchema, model, parentPath, definitions));
+    }
+
     if (schema.properties) {
       Object.entries(schema.properties).forEach(([propertyName, propertyValue]) => {
         const propertySchema = propertyValue as KaotoSchemaDefinition['schema'];
         // TODO
         if (propertySchema.type === 'array') return;
+        if (model?.[propertyName] && propertySchema.$ref) {
+          const path = parentPath ? `${parentPath}.${propertyName}` : propertyName;
+          const resolvedPropertySchema = resolveSchemaWithRef(propertySchema, definitions!);
+          answer.push(
+            ...this.validateRequiredProperties(resolvedPropertySchema, model[propertyName], path, definitions),
+          );
+        }
         if (propertySchema.type === 'object') {
           const path = parentPath ? `${parentPath}.${propertyName}` : propertyName;
           if (model) {
-            answer.push(...this.validateRequiredProperties(propertySchema, model[propertyName], path));
+            answer.push(...this.validateRequiredProperties(propertySchema, model[propertyName], path, definitions));
           }
           return;
         }
@@ -68,6 +101,7 @@ export class ModelValidationService {
           Array.isArray(schema.required) &&
           schema.required.includes(propertyName) &&
           propertySchema.default === undefined &&
+          propertySchema.$ref === undefined &&
           (!model || !model[propertyName])
         ) {
           answer.push({