Combine const and enum errors into a single message

[ShivaGupta-14]

Description

When multiple const or enum constraints fail (e.g., via allOf), produce a single message with the most restrictive constraint instead of multiple redundant messages.

• Compute the intersection of allowed values across all constraints
• If intersection has 1 value: use const message
• If intersection has multiple values: use enum message
• If intersection is empty (contradictory): use boolean schema message
• Fixes: Combine const and enum handlers #132

Checklist

• npm test
• npm run lint
• npm run type-check

[jdesrosiers]

This approach isn't going to work. Try,

{
  "allOf": [
    { "const": "a" },
    { "const": "b" }
  ]
}

[ShivaGupta-14]

This approach isn't going to work. Try,

{
  "allOf": [
    { "const": "a" },
    { "const": "b" }
  ]
}

Hi @jdesrosiers,

thanks for pointing out the issue! I understood the problem:

Issue: with a schema like above one -> allOf: [{ const: "a" }, { const: "b" }], if the instance is "a"

• const: "a" passes (not in errors)
• Only const: "b" fails
• My original code only saw failing constraints -> couldn't detect the contradiction
• My Solution: I updated the handler to collect ALL constraints (both passing and failing), then compute the intersection:

const passed = normalizedErrors[...][schemaLocation] === true;
if (!passed) hasFailure = true;
// always collect
constraints.push({ allowedValues: [...], schemaLocation });

now:

• Both ["a"] and ["b"] are collected
• Intersection = [] (empty)
• Returns getBooleanSchemaErrorMessage()

Tests Added:

• contradictory const - empty intersection (instance matches one const)
• contradictory enum - empty intersection (disjoint enum sets)

All tests pass. Is this approach good, or does it need further improvements?
Thanks!

[jdesrosiers]

That should work. Just a couple small things I'd like to see.

[jdesrosiers]

The logic to find the most constraining keyword felt off to me and I figured out a case where it doesn't work. Try,

{
  "allOf": [
    { "enum": ["a", "b", "c"] },
    { "enum": ["a", "b", "d"] },
    { "enum": ["a", "b", "e"] }
  ]
}

with,

"c"

It says, "Expected one of ⁨"a" or "b"⁩" with schema location /allOf/0/enum, but that's a passing location. If we exclude passing locations, we get a schema location of /allOf/1/enum, which is better, but it seems contradictory because the message says only "a" and "b" are allowed, but the schema location says that "d" is also allowed. That means we need to include all the failing schema locations to make it clear why only "a" and "b" are allowed. I think the only time we can collapse to a single most constraining location is when the effective allowed set matches exactly one of the keywords.

This is a tough one.

[jdesrosiers]

Another edge case to consider,

{
  "allOf": [
    { "enum": ["a", "b"] },
    { "enum": ["a", "b"] }
  ]
}

with,

"c"

Should one location be selected as the most constraining, or should we return both locations? I think either one is fine.

[ShivaGupta-14]

It says, "Expected one of ⁨"a" or "b"⁩" with schema location /allOf/0/enum, but that's a passing location. If we exclude passing locations, we get a schema location of /allOf/1/enum, which is better, but it seems contradictory because the message says only "a" and "b" are allowed, but the schema location says that "d" is also allowed. That means we need to include all the failing schema locations to make it clear why only "a" and "b" are allowed. I think the only time we can collapse to a single most constraining location is when the effective allowed set matches exactly one of the keywords.

Thanks for pointing it out, I missed it. for such cases, I’ve updated the logic.

• If the intersection matches exactly one constraint's values -> use that single location
• Otherwise -> include all constraint locations

this will handle edge case: when intersection is ["a","b"] but no single constraint has exactly ["a","b"], we show all locations so users understand why only "a" and "b" are valid.

also, test added for this case: "multiple enums with no exact match"

[ShivaGupta-14]

Should one location be selected as the most constraining, or should we return both locations? I think either one is fine.

return one since both are exactly the same in such cases. also, duplicate identical enums in real schemas are likely unintentional, so returning one seems sufficient.

[ShivaGupta-14]

Hi @jdesrosiers!, PTAL

[jdesrosiers]

Sorry this one has taken a while. It just hasn't felt right to me and I wanted some time to think about it some more. Mostly, it feels too complicated and I was hoping for something simpler that would be easier to maintain. I was able to take some time this weekend and I think I figured out something that works out well enough with a simple implementation. Here are the rules.

1. If the intersection is empty, return the boolean-schema-message and all schema locations whether they passed or failed.
2. If there are const errors, only use those schema locations. Otherwise, use the enum error schema locations.

The main thing that ends up being different from what we had is that it doesn't collapse the schema locations to a single value if there's an exact match. I think that's fine.

Let me know if you can think of any way where these rules can have problems.