Do not filter out errors for oneOf enums

The errorsAt function, used to filter the errors that belong to a
control, ignores the errors AJV produces for oneOf schemas. Most of
these errors should not be shown in the UI (e.g. when the oneOf property
does not match exactly one subschema), however the errors produced
directly for oneOf enums are an exception.

Validation errors for oneOf enum controls are valid and should be shown
in the UI.

Contributed on behalf of STMicroelectronics

Author: AlexandraBuzila

packages/core/src/reducers/core.ts

@@ -45,7 +45,7 @@ import {
   UPDATE_CORE,
   UpdateCoreAction,
 } from '../actions';
-import { createAjv, Reducer } from '../util';
+import { createAjv, isOneOfEnumSchema, Reducer } from '../util';
 import type { JsonSchema, UISchemaElement } from '../models';
 
 export const validate = (
@@ -389,7 +389,11 @@ export const errorsAt =
 
     return filter(errors, (error) => {
       // Filter errors that match any keyword that we don't want to show in the UI
-      if (filteredErrorKeywords.indexOf(error.keyword) !== -1) {
+      // but keep the errors for oneOf enums
+      if (
+        filteredErrorKeywords.indexOf(error.keyword) !== -1 &&
+        !isOneOfEnumSchema(error.parentSchema)
+      ) {
         return false;
       }
       const controlPath = getControlPath(error);
@@ -400,12 +404,13 @@ export const errorsAt =
       // In the primitive case the error's data path is the same for all subschemas:
       // It directly points to the property defining the anyOf/oneOf.
       // The same holds true for errors on the array level (e.g. min item amount).
-      // In contrast, this comparison must not be done for errors whose parent schema defines an object
+      // In contrast, this comparison must not be done for errors whose parent schema defines an object or a oneOf enum,
       // because the parent schema can never match the property schema (e.g. for 'required' checks).
       const parentSchema: JsonSchema | undefined = error.parentSchema;
       if (
         result &&
         !isObjectSchema(parentSchema) &&
+        !isOneOfEnumSchema(parentSchema) &&
         combinatorPaths.findIndex((p) => instancePath.startsWith(p)) !== -1
       ) {
         result = result && isEqual(parentSchema, schema);

packages/core/src/testers/testers.ts

@@ -37,7 +37,12 @@ import type {
   JsonSchema,
   UISchemaElement,
 } from '../models';
-import { deriveTypes, hasType, resolveSchema } from '../util';
+import {
+  deriveTypes,
+  hasType,
+  isOneOfEnumSchema,
+  resolveSchema,
+} from '../util';
 
 /**
  * Constant that indicates that a tester is not capable of handling
@@ -353,11 +358,7 @@ export const isEnumControl = and(
  */
 export const isOneOfEnumControl = and(
   uiTypeIs('Control'),
-  schemaMatches(
-    (schema) =>
-      schema.hasOwnProperty('oneOf') &&
-      (schema.oneOf as JsonSchema[]).every((s) => s.const !== undefined)
-  )
+  schemaMatches((schema) => isOneOfEnumSchema(schema))
 );
 
 /**
@@ -517,7 +518,7 @@ export const isObjectArrayWithNesting = (
           if (val.anyOf || val.allOf) {
             return true;
           }
-          if (val.oneOf && !isOneOfEnumControl(uischema, val, context)) {
+          if (val.oneOf && !isOneOfEnumSchema(val)) {
             return true;
           }
           if (hasType(val, 'object')) {

packages/core/src/util/schema.ts

@@ -24,6 +24,7 @@
 */
 
 import find from 'lodash/find';
+import { JsonSchema } from '../models';
 
 export const getFirstPrimitiveProp = (schema: any) => {
   if (schema.properties) {
@@ -38,3 +39,11 @@ export const getFirstPrimitiveProp = (schema: any) => {
   }
   return undefined;
 };
+
+/**
+ * Tests whether the schema has an enum based on oneOf.
+ */
+export const isOneOfEnumSchema = (schema: JsonSchema) =>
+  schema?.hasOwnProperty('oneOf') &&
+  schema?.oneOf &&
+  (schema.oneOf as JsonSchema[]).every((s) => s.const !== undefined);

packages/core/test/reducers/core.test.ts

@@ -861,6 +861,80 @@ test('errorAt filters array inner value', (t) => {
   t.deepEqual(filtered[0], state.errors[1]);
 });
 
+test('errorAt filters oneOf enum', (t) => {
+  const ajv = createAjv();
+  const schema: JsonSchema = {
+    type: 'object',
+    properties: {
+      oneOfEnum: {
+        type: 'string',
+        oneOf: [
+          { title: 'Number', const: '1' },
+          { title: 'Color', const: '2' },
+        ],
+      },
+    },
+  };
+  const data: { oneOfEnum: string } = { oneOfEnum: '3' };
+  const v = ajv.compile(schema);
+  const errors = validate(v, data);
+
+  const state: JsonFormsCore = {
+    data,
+    schema,
+    uischema: undefined,
+    errors,
+  };
+  const filtered = errorAt('oneOfEnum', schema.properties.oneOfEnum)(state);
+  t.is(filtered.length, 1);
+  // in the state, we get 3 errors: one for each const value in the oneOf (we have two consts here) and one for the oneOf property itself
+  // we only display the last error on the control
+  t.deepEqual(filtered[0], state.errors[2]);
+});
+
+test('errorAt filters array with inner oneOf enum', (t) => {
+  const ajv = createAjv();
+  const schema = {
+    type: 'object',
+    properties: {
+      parentArray: {
+        type: 'array',
+        items: {
+          type: 'object',
+          properties: {
+            oneOfEnumWithError: {
+              type: 'string',
+              oneOf: [
+                { title: 'Number', const: '1' },
+                { title: 'Color', const: '2' },
+              ],
+            },
+          },
+        },
+      },
+    },
+  };
+  const data: { parentArray: { oneOfEnumWithError: string }[] } = {
+    parentArray: [{ oneOfEnumWithError: 'test' }],
+  };
+  const v = ajv.compile(schema);
+  const errors = validate(v, data);
+  const state: JsonFormsCore = {
+    data,
+    schema,
+    uischema: undefined,
+    errors,
+  };
+  const filtered = errorAt(
+    'parentArray.0.oneOfEnumWithError',
+    schema.properties.parentArray.items.properties.oneOfEnumWithError
+  )(state);
+  t.is(filtered.length, 1);
+  // in the state, we get 3 errors: one for each const value in the oneOf (we have two consts here) and one for the oneOf property itself
+  // we only display the last error on the control
+  t.deepEqual(filtered[0], state.errors[2]);
+});
+
 test('errorAt filters oneOf simple', (t) => {
   const ajv = createAjv();
   const schema: JsonSchema = {

packages/examples/src/examples/arrays.ts

@@ -45,6 +45,10 @@ export const schema = {
             type: 'string',
             const: 'foo',
           },
+          oneOfEnum: {
+            type: 'string',
+            oneOf: [{ const: 'foo' }, { const: 'bar' }],
+          },
         },
       },
     },
@@ -95,6 +99,7 @@ export const data = {
     {
       date: new Date().toISOString().substr(0, 10),
       message: 'Get ready for booohay',
+      oneOfEnum: 'test',
     },
   ],
 };

packages/examples/src/examples/enum.ts

@@ -35,6 +35,10 @@ export const schema = {
       type: 'string',
       enum: ['foo', 'bar'],
     },
+    enumWithError: {
+      type: 'string',
+      enum: ['foo', 'bar'],
+    },
     oneOfEnum: {
       type: 'string',
       oneOf: [
@@ -51,6 +55,14 @@ export const schema = {
         { const: 'foobar', title: 'FooBar' },
       ],
     },
+    oneOfEnumWithError: {
+      type: 'string',
+      oneOf: [
+        { const: 'foo', title: 'Foo' },
+        { const: 'bar', title: 'Bar' },
+        { const: 'foobar', title: 'FooBar' },
+      ],
+    },
     constEnum: {
       const: 'Const Value',
     },
@@ -90,6 +102,10 @@ export const uischema = {
             autocomplete: false,
           },
         },
+        {
+          type: 'Control',
+          scope: '#/properties/enumWithError',
+        },
       ],
     },
     {
@@ -118,12 +134,21 @@ export const uischema = {
             autocomplete: false,
           },
         },
+        {
+          type: 'Control',
+          scope: '#/properties/oneOfEnumWithError',
+        },
       ],
     },
   ],
 };
 
-export const data = { plainEnumSet: 'foo', oneOfEnumSet: 'bar' };
+export const data = {
+  plainEnumSet: 'foo',
+  enumWithError: 'bogus',
+  oneOfEnumSet: 'bar',
+  oneOfEnumWithError: 'bogus',
+};
 
 registerExamples([
   {