Feature: validator-ajv8: Add support for suppressing duplicate filtering (#5032)

* Feature: validator-ajv8: Add support for suppressing duplicate filtering
Fixes #5028 by adding configuration support to the `validator-ajv8` to suppress duplicate filtering
- Updated `CustomValidatorOptionsType` to add new `suppressDuplicateFiltering` flag prop
- Updated `AJV8Validator`, `AJV8PrecompiledValidator` and `createPrecompiledValidator()` to support passing the new flag prop
- Updated `processRawValidationErrors()` to pass the new flag prop into `transformRJSFValidationErrors()`
- Refactored the filtering of duplicates to a new `filterDuplicateErrors()` function that takes the new flag prop and suppresses the appropriate filtering
- Updated the unit tests to verify the flag works as intended
- Updated the `validator-ajv8.md` and `validation.md` docs for the new flag prop
- Updated the `CHANGELOG.md` accordingly

* - Responded to reviewer feedback. Added 'none' value

* - Updated example schema in `validation.md` to match schema from #5028

Author: heath-freenome

CHANGELOG.md

@@ -77,10 +77,15 @@ should change the heading of the (upcoming) version to include a major version b
 - Updated `getInputProps()` to propagate `formatMinimum` and `formatMaximum` schema keywords to the HTML `min`/`max` attributes for `date`, `datetime-local`, `time`, `week`, and `month` input types, aligning browser-native date picker constraints with AJV validation
 - Fixed `ui:title` from `ui:definitions` not applied to `oneOf`/`anyOf` dropdowns beyond first recursion level, fixing [#4986](https://github.com/rjsf-team/react-jsonschema-form/issues/4986)
 
+# @rjsf/validator-ajv8
+
+- Updated `CustomValidatorOptionsType` to add the new `suppressDuplicateFiltering` flag prop, updating the validators to pass it through to the `transformRJSFValidationErrors()` which suppresses the appropriate duplicate errors if specified, fixing [#5028](https://github.com/rjsf-team/react-jsonschema-form/issues/5028)
+
 ## Dev / docs / playground
 
 - Updated References playground sample to demonstrate `oneOf` with `ui:title` at recursive depth, related to [#4986](https://github.com/rjsf-team/react-jsonschema-form/issues/4986)
 - Updated the building of the `mantine` theme to properly support ESM, fixing [#5025](https://github.com/rjsf-team/react-jsonschema-form/issues/5025)
+- Updated the `validator-ajv8.md` and `validation.md` documetation for the new `suppressDuplicateFiltering` configuration prop
 
 # 6.4.2
 

packages/docs/docs/api-reference/validator-ajv8.md

@@ -20,7 +20,14 @@ If a `localizer` is provided, it is used to translate the messages generated by
 
 #### Parameters
 
-- [options={}]: CustomValidatorOptionsType - The optional map of `CustomValidatorOptionsType` options that are used to create the `ValidatorType` instance
+- [options={}]: CustomValidatorOptionsType - The optional map of `CustomValidatorOptionsType` options that are used to create the `ValidatorType` instance. Supported options:
+  - `additionalMetaSchemas`: Additional meta schemas the validator can access
+  - `customFormats`: Additional custom format validators
+  - `ajvOptionsOverrides`: Config overrides passed to the AJV constructor
+  - `ajvFormatOptions`: Options for `ajv-formats`; pass `false` to disable format support entirely
+  - `AjvClass`: The AJV class to construct (e.g. `Ajv2019`, `Ajv2020`)
+  - `extenderFn`: A function called to extend the AJV instance (e.g. `ajvErrors()`)
+  - `suppressDuplicateFiltering`: Controls filtering of duplicate `anyOf`/`oneOf` errors using the `SuppressDuplicateFilteringType` type. `'none'` (default) filters duplicates for both; `'anyOf'` suppresses filtering for `anyOf` (oneOf duplicates still filtered); `'oneOf'` suppresses filtering for `oneOf` (anyOf duplicates still filtered); `'all'` disables all duplicate filtering.
 - [localizer]: Localizer | undefined - If provided, is used to localize a list of Ajv `ErrorObject`s after running the form validation using AJV
 
 #### Returns
@@ -51,6 +58,7 @@ If a `localizer` is provided, it is used to translate the messages generated by
 - validateFns: ValidatorFunctions - The map of the validation functions that are created by the `compileSchemaValidators()` function
 - rootSchema: S - The root schema that was used with the `compileSchemaValidators()` function
 - [localizer]: Localizer | undefined - If provided, is used to localize a list of Ajv `ErrorObject`s after running the form validation using AJV
+- [suppressDuplicateFiltering]: `SuppressDuplicateFilteringType | undefined` - Controls filtering of duplicate `anyOf`/`oneOf` errors. See `customizeValidator()` for full description of each value.
 
 #### Returns
 

packages/docs/docs/usage/validation.md

@@ -707,6 +707,78 @@ const validator = customizeValidator({ extenderFn: ajvErrors });
 render(<Form schema={schema} validator={validator} />, document.getElementById('app'));
 ```
 
+### suppressDuplicateFiltering
+
+When AJV validates against `anyOf` or `oneOf` schemas, it generates a separate error for each failed branch, which often produces many duplicate messages.
+By default, the validator filters out these duplicates so that only the first occurrence of each unique error is shown.
+Use `suppressDuplicateFiltering` to override this behavior when you need to see all errors from every branch.
+
+The option accepts a `SuppressDuplicateFilteringType` value (exported from `@rjsf/validator-ajv8`):
+
+| Value              | Behavior                                                                    |
+| ------------------ | --------------------------------------------------------------------------- |
+| `'none'` (default) | Duplicates filtered for both `anyOf` and `oneOf`                            |
+| `'anyOf'`          | `anyOf` duplicate filtering disabled; `oneOf` duplicates still filtered     |
+| `'oneOf'`          | `oneOf` duplicate filtering disabled; `anyOf` duplicates still filtered     |
+| `'all'`            | All duplicate filtering disabled; every error from every branch is returned |
+
+For a standard validator via `customizeValidator()`:
+
+```tsx
+import { Form } from '@rjsf/core';
+import { RJSFSchema } from '@rjsf/utils';
+import { customizeValidator } from '@rjsf/validator-ajv8';
+
+const schema: RJSFSchema = {
+  type: 'object',
+  properties: {
+    asc: {
+      title: 'Low to high',
+      type: 'boolean',
+      default: true,
+    },
+    desc: {
+      title: 'High to low',
+      type: 'boolean',
+      default: true,
+    },
+  },
+  anyOf: [
+    {
+      required: ['asc'],
+      properties: {
+        asc: {
+          const: true,
+        },
+      },
+    },
+    {
+      required: ['desc'],
+      properties: {
+        desc: {
+          const: true,
+        },
+      },
+    },
+  ],
+};
+
+// Disable all duplicate filtering — show every error from every anyOf/oneOf branch
+const validator = customizeValidator({ suppressDuplicateFiltering: 'all' });
+
+render(<Form schema={schema} validator={validator} />, document.getElementById('app'));
+```
+
+For a precompiled validator, pass the value as the fourth argument to `createPrecompiledValidator()`:
+
+```tsx
+import { createPrecompiledValidator } from '@rjsf/validator-ajv8';
+import * as precompiledValidatorFns from 'path_to/yourCompiledSchema';
+import yourSchema from 'path_to/yourSchema';
+
+const validator = createPrecompiledValidator(precompiledValidatorFns, yourSchema, undefined, 'all');
+```
+
 ### Localization (L10n) support
 
 The Ajv 8 validator supports the localization of error messages using [ajv-i18n](https://github.com/ajv-validator/ajv-i18n).

packages/validator-ajv8/src/createPrecompiledValidator.ts

@@ -1,6 +1,6 @@
 import { FormContextType, RJSFSchema, StrictRJSFSchema, ValidatorType } from '@rjsf/utils';
 
-import { Localizer, ValidatorFunctions } from './types';
+import { Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';
 import AJV8PrecompiledValidator from './precompiledValidator';
 
 /** Creates and returns a `ValidatorType` interface that is implemented with a precompiled validator. If a `localizer`
@@ -12,12 +12,18 @@ import AJV8PrecompiledValidator from './precompiledValidator';
  * @param validateFns - The map of the validation functions that are created by the `compileSchemaValidators()` function
  * @param rootSchema - The root schema that was used with the `compileSchemaValidators()` function
  * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
  * @returns - The precompiled validator implementation resulting from the set of parameters provided
  */
 export default function createPrecompiledValidator<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
->(validateFns: ValidatorFunctions, rootSchema: S, localizer?: Localizer): ValidatorType<T, S, F> {
-  return new AJV8PrecompiledValidator<T, S, F>(validateFns, rootSchema, localizer);
+>(
+  validateFns: ValidatorFunctions,
+  rootSchema: S,
+  localizer?: Localizer,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+): ValidatorType<T, S, F> {
+  return new AJV8PrecompiledValidator<T, S, F>(validateFns, rootSchema, localizer, suppressDuplicateFiltering);
 }

packages/validator-ajv8/src/precompiledValidator.ts

@@ -16,7 +16,7 @@ import {
   ValidatorType,
 } from '@rjsf/utils';
 
-import { CompiledValidateFunction, Localizer, ValidatorFunctions } from './types';
+import { CompiledValidateFunction, Localizer, SuppressDuplicateFilteringType, ValidatorFunctions } from './types';
 import processRawValidationErrors, { RawValidationErrorsType } from './processRawValidationErrors';
 
 /** `ValidatorType` implementation that uses an AJV 8 precompiled validator as created by the
@@ -51,17 +51,30 @@ export default class AJV8PrecompiledValidator<
    */
   readonly localizer?: Localizer;
 
+  /** Controls which duplicate error filtering is suppressed; see `filterDuplicateErrors`
+   *
+   * @private
+   */
+  readonly suppressDuplicateFiltering?: SuppressDuplicateFilteringType;
+
   /** Constructs an `AJV8PrecompiledValidator` instance using the `validateFns` and `rootSchema`
    *
    * @param validateFns - The map of the validation functions that are generated by the `schemaCompile()` function
    * @param rootSchema - The root schema that was used with the `compileSchema()` function
    * @param [localizer] - If provided, is used to localize a list of Ajv `ErrorObject`s
+   * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
    * @throws - Error when the base schema of the precompiled validator does not have a matching validator function
    */
-  constructor(validateFns: ValidatorFunctions, rootSchema: S, localizer?: Localizer) {
+  constructor(
+    validateFns: ValidatorFunctions,
+    rootSchema: S,
+    localizer?: Localizer,
+    suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+  ) {
     this.rootSchema = rootSchema;
     this.validateFns = validateFns;
     this.localizer = localizer;
+    this.suppressDuplicateFiltering = suppressDuplicateFiltering;
     this.mainValidator = this.getValidator(rootSchema);
   }
 
@@ -142,7 +155,16 @@ export default class AJV8PrecompiledValidator<
     uiSchema?: UiSchema<T, S, F>,
   ): ValidationData<T> {
     const rawErrors = this.rawValidation<ErrorObject>(schema, formData);
-    return processRawValidationErrors(this, rawErrors, formData, schema, customValidate, transformErrors, uiSchema);
+    return processRawValidationErrors(
+      this,
+      rawErrors,
+      formData,
+      schema,
+      customValidate,
+      transformErrors,
+      uiSchema,
+      this.suppressDuplicateFiltering,
+    );
   }
 
   /** Validates data against a schema, returning true if the data is valid, or false otherwise. If the schema is

packages/validator-ajv8/src/processRawValidationErrors.ts

@@ -20,22 +20,68 @@ import {
   ValidatorType,
 } from '@rjsf/utils';
 
+import { SuppressDuplicateFilteringType } from './types';
+
 export type RawValidationErrorsType<Result = any> = {
   errors?: Result[];
   validationError?: Error;
 };
 
+/** Filters duplicate errors from `anyOf`/`oneOf` schema paths according to the `suppressDuplicateFiltering` flag.
+ *
+ * @param errorList - The list of `RJSFValidationError`s to filter
+ * @param [suppressDuplicateFiltering='none'] - Controls which duplicate filtering is suppressed:
+ *   - `'none'` (default): filters duplicates for both `anyOf` and `oneOf`
+ *   - `'all'`: returns `errorList` unmodified
+ *   - `'anyOf'`: suppresses filtering for `anyOf` errors; `oneOf` duplicates are still filtered
+ *   - `'oneOf'`: suppresses filtering for `oneOf` errors; `anyOf` duplicates are still filtered
+ */
+export function filterDuplicateErrors(
+  errorList: RJSFValidationError[],
+  suppressDuplicateFiltering: SuppressDuplicateFilteringType = 'none',
+): RJSFValidationError[] {
+  if (suppressDuplicateFiltering === 'all') {
+    return errorList;
+  }
+  return errorList.reduce((acc: RJSFValidationError[], err: RJSFValidationError) => {
+    const { message, schemaPath } = err;
+    // Compute the index only when filtering for that keyword is not suppressed.
+    // 'all' is already handled above; within the reduce, only 'none', 'anyOf', and 'oneOf' are possible.
+    const anyOfIndex = suppressDuplicateFiltering !== 'anyOf' ? schemaPath?.indexOf(`/${ANY_OF_KEY}/`) : undefined;
+    const oneOfIndex = suppressDuplicateFiltering !== 'oneOf' ? schemaPath?.indexOf(`/${ONE_OF_KEY}/`) : undefined;
+    let schemaPrefix: string | undefined;
+    if (anyOfIndex && anyOfIndex >= 0) {
+      schemaPrefix = schemaPath?.substring(0, anyOfIndex);
+    } else if (oneOfIndex && oneOfIndex >= 0) {
+      schemaPrefix = schemaPath?.substring(0, oneOfIndex);
+    }
+    // If there is a schemaPrefix, then search for a duplicate message with the same prefix, otherwise undefined
+    const dup = schemaPrefix
+      ? acc.find((e: RJSFValidationError) => e.message === message && e.schemaPath?.startsWith(schemaPrefix))
+      : undefined;
+    if (!dup) {
+      acc.push(err);
+    }
+    return acc;
+  }, [] as RJSFValidationError[]);
+}
+
 /** Transforming the error output from ajv to format used by @rjsf/utils.
  * At some point, components should be updated to support ajv.
  *
  * @param errors - The list of AJV errors to convert to `RJSFValidationErrors`
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
  */
 export function transformRJSFValidationErrors<
   T = any,
   S extends StrictRJSFSchema = RJSFSchema,
   F extends FormContextType = any,
->(errors: ErrorObject[] = [], uiSchema?: UiSchema<T, S, F>): RJSFValidationError[] {
+>(
+  errors: ErrorObject[] = [],
+  uiSchema?: UiSchema<T, S, F>,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
+): RJSFValidationError[] {
   const errorList = errors.map((e: ErrorObject) => {
     const { instancePath, keyword, params, schemaPath, parentSchema, ...rest } = e;
     let { message = '' } = rest;
@@ -107,28 +153,7 @@ export function transformRJSFValidationErrors<
       title: uiTitle,
     };
   });
-  // Filter out duplicates around anyOf/oneOf messages
-  return errorList.reduce((acc: RJSFValidationError[], err: RJSFValidationError) => {
-    const { message, schemaPath } = err;
-    const anyOfIndex = schemaPath?.indexOf(`/${ANY_OF_KEY}/`);
-    const oneOfIndex = schemaPath?.indexOf(`/${ONE_OF_KEY}/`);
-    let schemaPrefix: string | undefined;
-    // Look specifically for `/anyOr/` or `/oneOf/` within the schemaPath information
-    if (anyOfIndex && anyOfIndex >= 0) {
-      schemaPrefix = schemaPath?.substring(0, anyOfIndex);
-    } else if (oneOfIndex && oneOfIndex >= 0) {
-      schemaPrefix = schemaPath?.substring(0, oneOfIndex);
-    }
-    // If there is a schemaPrefix, then search for a duplicate message with the same prefix, otherwise undefined
-    const dup = schemaPrefix
-      ? acc.find((e: RJSFValidationError) => e.message === message && e.schemaPath?.startsWith(schemaPrefix))
-      : undefined;
-    if (!dup) {
-      // Only push an error that is not a duplicate
-      acc.push(err);
-    }
-    return acc;
-  }, [] as RJSFValidationError[]);
+  return filterDuplicateErrors(errorList, suppressDuplicateFiltering);
 }
 
 /** This function processes the `formData` with an optional user contributed `customValidate` function, which receives
@@ -143,6 +168,7 @@ export function transformRJSFValidationErrors<
  * @param [customValidate] - An optional function that is used to perform custom validation
  * @param [transformErrors] - An optional function that is used to transform errors after AJV validation
  * @param [uiSchema] - An optional uiSchema that is passed to `transformErrors` and `customValidate`
+ * @param [suppressDuplicateFiltering] - Controls which duplicate filtering is suppressed; see `filterDuplicateErrors`
  */
 export default function processRawValidationErrors<
   T = any,
@@ -156,9 +182,10 @@ export default function processRawValidationErrors<
   customValidate?: CustomValidator<T, S, F>,
   transformErrors?: ErrorTransformer<T, S, F>,
   uiSchema?: UiSchema<T, S, F>,
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType,
 ) {
   const { validationError: invalidSchemaError } = rawErrors;
-  let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema);
+  let errors = transformRJSFValidationErrors<T, S, F>(rawErrors.errors, uiSchema, suppressDuplicateFiltering);
 
   if (invalidSchemaError) {
     errors = [...errors, { stack: invalidSchemaError!.message }];

packages/validator-ajv8/src/types.ts

@@ -1,6 +1,9 @@
 import Ajv, { Options, ErrorObject } from 'ajv';
 import { FormatsPluginOptions } from 'ajv-formats';
 
+/** The type describing the value for the `suppressDuplicateFiltering` option */
+export type SuppressDuplicateFilteringType = 'anyOf' | 'oneOf' | 'all' | 'none';
+
 /** The type describing how to customize the AJV6 validator
  */
 export interface CustomValidatorOptionsType {
@@ -18,6 +21,13 @@ export interface CustomValidatorOptionsType {
   AjvClass?: typeof Ajv;
   /** A function to call to extend AJV, such as `ajvErrors()` */
   extenderFn?: (ajv: Ajv) => Ajv;
+  /** When set, suppresses duplicate error filtering for the specified keyword(s):
+   * - `'none'` (default): both `anyOf` and `oneOf` duplicate errors are filtered
+   * - `'all'`: disables all duplicate filtering
+   * - `'anyOf'`: disables filtering for `anyOf` errors only (oneOf duplicates are still filtered)
+   * - `'oneOf'`: disables filtering for `oneOf` errors only (anyOf duplicates are still filtered)
+   */
+  suppressDuplicateFiltering?: SuppressDuplicateFilteringType;
 }
 
 /** The type describing a function that takes a list of Ajv `ErrorObject`s and localizes them