Enhancement: Collapse overlapping numeric constraint error messages in anyOf/oneOf

[srivastava-diya]

Problem Description

Currently, when validating against an anyOf or oneOf schema that has multiple overlapping numeric or string constraints, the error output returns a separate message for every failed alternative like so ,

{
  "anyOf": [
    {
      "type": "string",
      "maxLength": 2
    },
    {
      "type": "string",
      "maxLength": 4
    }
  ]
}

• If we validate an instance like "hello" (length 5), the errors retured are:

Expected one or more of the alternatives to pass validation:
- Expected a string with no more than 2 characters
- Expected a string with no more than 4 characters

Proposed Enhancement

As pointed out by @jdesrosiers here since these constraints are somehow testing the same attribute (string length) and one constraint is a subset of the other, they could be collapsed into a single, more concise error message.

For the example above, the ideal collapsed output for the user would be:

"Expected a string with no more than 4 characters"

Opening this issue to discuss

• What logic should be used to determine if two alternative errors are collapsible?
• Feedback and suggestions are very welcome.

[Ahmedmhmud]

I think it can be done in two different ways but the same logic
Since we have the access on the instance, we can get the best constraint value if it is in multiple alternatives by iterating on them but there is something that will make the logic too complex
We want two know if the alternatives are identical except in the targeted keywords like minLength, so

Recommended logic:
We make a new directory as a selection tool to use in the error handler method of the targeted keywords that may include more than one alternative (anyOf, oneOf, ... )
They use the alternative object that is resulted from the logic of the error handler like that:

const anyOfErrorHandler = async (normalizedErrors, instance, localization) => {
  /** @type ErrorObject[] */
  const errors = [];

  for (const schemaLocation in normalizedErrors["https://json-schema.org/keyword/anyOf"]) {
    const anyOf = normalizedErrors["https://json-schema.org/keyword/anyOf"][schemaLocation];
    if (typeof anyOf === "boolean") {
      continue;
    }

    const alternatives = [];
    for (const alternative of anyOf) {
      alternatives.push(await getErrors(alternative, instance, localization));
    }

    // Use the selector methods to collapse the duplicated messages of the same type

    errors.push({
      message: localization.getAnyOfErrorMessage(),
      alternatives: alternatives,
      instanceLocation: Instance.uri(instance),
      schemaLocations: [schemaLocation]
    });
  }

  return errors;
};

By iterating the alternatives for each keyword that causes the duplication and see the best one to choose over the others like it is done in maxLength error handler for example
This will take some time but overall it is for very specific keywords like allOf that accept multiple alternatives, and we can optimize it by choosing the proper data structure for storing the errors.

[animeshsahoo1]

If we intercept the errors before getErrors runs, we can work directly with the raw NormalizedOutput data.
Here is what i have thought of:

1. create a map with "Failure Unique Key"
   first, we look at exactly which keywords caused each alternative to fail. We create a "unique key" (a sorted list of the failed keyword URIs) and group the alternatives together. Two alternatives only end up in the same bucket if they failed for the exact same reasons.

2. Filter for Collapsible Rules
   next, we check if the group is safe to merge. We only want to collapse groups where every failed keyword is a simple boundary limit (e.g., maximum, minimum, maxLength, minLength, maxItems, maxProperties, etc).
   If a group tripped up on a structural rule like type, pattern, etc we back off and leave the errors exactly as they are.

3. Collapse to widest Rule
   For the groups that are safe to collapse, we just reduce them down to the biggest limit. We keep the largest value for "max" rules and the smallest value for "min" rules.

example:
{
"anyOf": [
{ "type": "string", "maxLength": 2 },
{ "type": "string", "maxLength": 4 }
]
}

case A: The data is a string
The type check passes for both, but maxLength fails for both.
The Fingerprint: ["maxLength"].
Since maxLength is on our safe list, we group them and keep the most permissive rule (maxLength: 4).

casee B: The data is a number
Now, both type and maxLength fail.
The unique key: ["type", "maxLength"]
Because type is not on our safe list, the filter stops the collapse. Both alternatives are shown normally to the user so they can see exactly where the structure broke down.

[Sam-61s]

My suggestion over this issue is in two phases

Phase 1 — Fix inconsistent boundary handlers first.
minimum.js and maximum.js currently emit one error per violation, which should give the most permissive value. Before cross-alternative collapsing, we should have to make all boundary handlers consistent — maximum.js keeps highest value, minimum.js keeps lowest. Same pattern for exclusiveMaximum, exclusiveMinimum, maxItems, maxProperties etc.

Phase 2 — Cross-alternative collapsing in anyOf.js / oneOf.js.
As @animeshsahoo1 suggested, work at the NormalizedOutput level before getErrors runs. For each alternative, compute a failure fingerprint — the sorted list of keyword URIs that have any failing entry. Group alternatives with identical fingerprints. Only collapse a group if every keyword in the fingerprint belongs to this safe list: maxLength, minLength, maximum, minimum, exclusiveMaximum, maxItems, maxProperties etc. If any keyword outside this list appears (type, const, enum, pattern, etc.), leave those alternatives uncollapsed. For safe groups, merge their NormalizedOutput objects into one and call getErrors once — the Phase 1 handlers then automatically pick the most permissive value from the merged data, so no new collapsing logic is needed elsewhere.

Example

{ "anyOf": [
  { "type": "string", "maxLength": 2 },
  { "type": "string", "maxLength": 4 },
  { "type": "number", "minimum": 2 }
]}

Instance: "hello"

Group A (alts 0 + 1): fingerprint ["maxLength"] — in safe list → merge
"Expected a string with no more than 4 characters"

Group B (alt 2): fingerprint ["minimum", "type"] — type not in safe list → keep as-is

Final anyOf error has two alternatives instead of three — one for the collapsed string constraint, one for the number branch.

[suruanush]

This PR introduces Error Collapsing for anyOf and oneOf schemas to eliminate redundant validation noise. Currently, if an input fails multiple overlapping constraints—such as maxLength: 2 and maxLength: 4—the validator outputs every failure, overwhelming the developer with a "wall of text."My solution implements a Widest Constraint filter. When multiple sub-schemas fail on the same attribute, the engine identifies the least restrictive threshold and surfaces only that error.