fix: recursively check for validity of discriminator

The old implementation was only checking for a single level of validity
of a schema using the discriminator extension, without accounting for
"unions of unions". So, for example:

```json
{
  "discriminator": {
    "propertyName": "field"
  }
  "required": ["field"],
  "oneOf": [
    {
      "oneOf": [
        {
          "properties": {
            "field": { "const": "a" }
          },
          "required": ["field"]
        },
        {
          "properties": {
            "field": { "const": "b" }
          },
          "required": ["field"]
        }
      ],
      "required": ["field"]
    },
    {
      "properties": {
        "field": { "const": "c" }
      },
      "required": ["field"]
    }
  ]
}
```

This schema would fail because the compiler would complain about the
first schema in `oneOf` not having the `field` property, which was
defined as the `discriminator`. But it *does* have that property, just
in a subschema inside another `oneOf` definition!

Author: AmadeusK525

lib/vocabularies/discriminator/index.ts

@@ -64,28 +64,75 @@ const def: CodeKeywordDefinition = {
       const oneOfMapping: {[T in string]?: number} = {}
       const topRequired = hasRequired(parentSchema)
       let tagRequired = true
-      for (let i = 0; i < oneOf.length; i++) {
-        let sch = oneOf[i]
+      addOneOfMappings(oneOf, topRequired)
+      if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
+      return oneOfMapping
+
+      function hasRequired({required}: AnySchemaObject): boolean {
+        return Array.isArray(required) && required.includes(tagName)
+      }
+
+      function resolveOneOfSchema(sch: AnySchemaObject): AnySchemaObject {
         if (sch?.$ref && !schemaHasRulesButRef(sch, it.self.RULES)) {
           const ref = sch.$ref
-          sch = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
-          if (sch instanceof SchemaEnv) sch = sch.schema
-          if (sch === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
-        }
-        const propSch = sch?.properties?.[tagName]
-        if (typeof propSch != "object") {
+          const resolved = resolveRef.call(it.self, it.schemaEnv.root, it.baseId, ref)
+          const schema = resolved instanceof SchemaEnv ? resolved.schema : resolved
+          if (schema === undefined) throw new MissingRefError(it.opts.uriResolver, it.baseId, ref)
+          if (typeof schema === "object") return schema
           throw new Error(
             `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
           )
         }
-        tagRequired = tagRequired && (topRequired || hasRequired(sch))
-        addMappings(propSch, i)
+        return sch
       }
-      if (!tagRequired) throw new Error(`discriminator: "${tagName}" must be required`)
-      return oneOfMapping
 
-      function hasRequired({required}: AnySchemaObject): boolean {
-        return Array.isArray(required) && required.includes(tagName)
+      function findTagPropSchema(sch: AnySchemaObject): AnySchemaObject | undefined {
+        const propSch = sch?.properties?.[tagName]
+        if (typeof propSch === "object") return propSch
+        const candidates = sch.allOf ?? sch.anyOf
+        if (Array.isArray(candidates)) {
+          for (const subSch of candidates) {
+            const resolved = resolveOneOfSchema(subSch)
+            const found = findTagPropSchema(resolved)
+            if (found) return found
+          }
+        }
+        return undefined
+      }
+
+      function checkRequired(sch: AnySchemaObject, parentRequired: boolean): boolean {
+        if (parentRequired || hasRequired(sch)) return true
+        const candidates = sch.allOf ?? sch.anyOf
+        if (Array.isArray(candidates)) {
+          for (const subSch of candidates) {
+            const resolved = resolveOneOfSchema(subSch)
+            if (checkRequired(resolved, false)) return true
+          }
+        }
+        return false
+      }
+
+      function addOneOfMappings(
+        oneOfSubschemas: AnySchemaObject[],
+        parentRequired: boolean,
+        topLevelIndex?: number
+      ): void {
+        for (let i = 0; i < oneOfSubschemas.length; i++) {
+          const mappingIndex = topLevelIndex ?? i
+          const sch = resolveOneOfSchema(oneOfSubschemas[i])
+          const propSch = findTagPropSchema(sch)
+          if (typeof propSch === "object") {
+            tagRequired = tagRequired && checkRequired(sch, parentRequired)
+            addMappings(propSch, mappingIndex)
+          } else if (sch?.oneOf && sch?.discriminator?.propertyName === tagName) {
+            tagRequired = tagRequired && checkRequired(sch, parentRequired)
+            addOneOfMappings(sch.oneOf as AnySchemaObject[], hasRequired(sch), mappingIndex)
+          } else {
+            throw new Error(
+              `discriminator: oneOf subschemas (or referenced schemas) must have "properties/${tagName}"`
+            )
+          }
+        }
       }
 
       function addMappings(sch: AnySchemaObject, i: number): void {