OpenAPI discriminator keyword

[HusseinKabbout]

I was looking into an issue I had with libopenapi-validator (which uses jsonschema for validation) and came to the conclusion that the discriminator feature of OpenAPI cannot be easily supported currently because jsonschema does not provide a way to extend the validation logic. In this case it is the logic for conditional keywords like oneOf. Obviously, this has not much to do with this library since we are talking about OpenAPI but maybe someone has an idea on how this could be implemented / improved.

The problem is the following: OpenAPI has a conditional keyword named oneOf. What that does is it makes object schemas conditional and enables having multiple schemas for one object. This is useful for when for example you have a login endpoint and want to support multiple ways to log into the application. To help with this, the discriminator keyword can be defined to improve the schema matching.

My question here is, how could this be implemented with this library? Would it make sense to add a way to extend validation logic directly in jsonschema? I would contribute and help implementing this feature if it makes sense.

[santhosh-tekuri]

It seems you have confused. there is no relation between discriminator and oneOf keywords.
discriminator takes subschemas. and in most cases these subschemas have oneOf.

have you seen https://github.com/santhosh-tekuri/jsonschema/blob/boon/example_vocab_discriminator_test.go

this is an implementation of discriminator keyword. but its structure is little bit different compared to openapi spec. you can take the above code and with some minor changes you can convert it to openapi's discriminator keyword

[HusseinKabbout]

It seems you have confused. there is no relation between discriminator and oneOf keywords.

The OpenAPI specification says, the Discriminator Object is legal only when using one of the composite keywords oneOf, anyOf, allOf. From that I understand that they are related and the discriminator can't actually be used alone.

[santhosh-tekuri]

that limitation is enforced by openapi. but from jsonschema point of view such restriction is not necessary. the current implementation works whether you use oneof, anyof, allof or not; so that should not be problem.

I recommend you modify the code I mentioned in earlier comment to reflect the structure of openapi spec.

the next release of jsonschema specification is planning to add discriminator keyword but with different structure than in openapi spec. the example I showed implements the new structure proposed by the team. I implemented it as a test case, so that when next spec is released I can make it official keyword. I guess once discriminator keyword is added officially, that will be used by next openapi spec.

[HusseinKabbout]

First of all, thanks for answering so fast! Really appreciated! I think you are missunderstanding me, I know that this is only enforced by OpenAPI but the OpenAPI library (libopenapi-validator), which I am using , uses this library for validation and therefore the need for considering discriminator in the validation of oneOf, anyOf, allOf comes into play. I am curently exploring whether using this library makes it possible to support this.

[santhosh-tekuri]

let me make it more clear.

there are two validations here.

1. the validation of the usage of discriminator keyword: where the spec says if discriminator keyword used it must have XXXOf
2. validation of json sample with schema containing discriminator keyword

I am talking about about the 2. the sample I provided can do this. whether there is 1 satisfied or not.

if you want to enforce 1. that means you are validating or enforcing user how to use the discriminator keyword in your schema.
that can also be done with the library. the schema here tells how to validate discriminator usage. if you want you can enforce that restriction here.

[HusseinKabbout]

Exactly, what I want is the second validation. When a HTTP request comes in, I want to validate if the request is accepted by the preconfigured OpenAPI schema. I guess, I can introduce a new vocab for the combination of discriminator and xxxOf but the already existing validation that happens here for conditionals will still run and fail. That can't be turned off at the moment. The issue is not about introducing new validation behaviour but altering existing behaviour. vd.condValidate() will always run without being able to affect how the validation is done and it can't be skipped.

[santhosh-tekuri]

it seems this discussion is not reaching any conclusion.

Just give me minimal openapi sample file, and input json, I will show how to do the validation.

[HusseinKabbout]

Thanks for implementing this so fast! But still, the examples you show are always about using the discriminator alone. But in OpenAPI when XXXOf and discriminator are both specified then they are not validated separately but together. That means the discriminator has direct influence on how XXXOf is going to be validated. As I said above, vd.condValidate does not support this. So it does not matter if the vocab is registered or if there is a SchemaExt that does the correct validation. vd.condValidate will always be executed when validating against a schema, which will also always fail with my example from above.

[santhosh-tekuri]

when discriminator has mapping field then oneOf is unnecessary. it is just doing same validation twice.

my guess is not all openapi libraries implement discriminator keyword validation. so in such cases you at least have oneOf validation. if you want to force to have oneOf then you can change the schema at line 47. you can use if keyword in such case.

oneOf is standard keyword. custom keyword cannot effect how it works. if they really want it to behave it differently they should have added oneOf property inside discriminator object, in such case it is no longer recognised as standard keyword, and you are allowed to write your own oneOf validation for that.

[santhosh-tekuri]

which will also always fail with my example from above.

it seems your oneOf is wrong. check it.

adding oneOf in my example should not fail

[santhosh-tekuri]

when I checked your schema it is giving the following error:
- at '': 'oneOf' failed, subschemas 0, 3 matched

you have to correct your schema, you have to make one of the following changes:

• use anyOf instead of oneOf
• or in each of schemas in oneOf add condition for value of method property as shown below:

"method": { "const": "ACTUAL_VALUE_HERE" }

[HusseinKabbout]

Thanks for being so patient with me! I was misunderstanding how discriminator should be used in OpenAPI. According to the spec, it must not change the validation result. So having oneOf fail is actually the intended behavior.

you have to correct your schema, you have to make one of the following changes:

The second approach looks better to me since the spec needs to enforce that a body matches exactly one schema.