split multiple types into anyOf subschema

[6293]

Closes #16

[untitaker]

we already have a conversion function for the opposite direction on crate::diff_walker::schemars_to_own. The reasoning at the time was that we don't want to make the conversion public API, but I actually have no strong opinion on it.

please either:

• change this to be a simple function in crate::diff_walker
• change schemars_to_own to be a impl From<InstanceType> for JsonSchemaType

the choice is yours, but they should be next to each other to ensure they are consistent

[6293]

I like the latter idea

[untitaker]

I believe you can just do *schema_object = new_object, and change function signature to (&mut SchemaObject) -> bool, then you can avoid a clone() in case you don't need to change the schema

[6293]

thank you for the insight

[untitaker]

This is a completely unrealistic schema (I hope), but I'm just curious, do you think it is possible to handle this case and produce no diff?

        let lhs = json! {{
            "anyOf": [
                {"properties": {"foo": {"type": "integer"}}},
                {"properties": {"foo": {"type": "string"}}}
            ]
        }};
        let rhs = json! {{
            "properties": {
                "foo": {
                    "type": ["integer", "string"]
                }
            }
        }};

[untitaker]

Thank you!

[6293]

This is a completely unrealistic schema (I hope), but I'm just curious, do you think it is possible to handle this case and produce no diff?

We will need another internal conversion, though we should not convert them into rhs-ish style like the following:

{"properties": {"foo": {"anyOf": [{"type": "integer"}, {"type": "string"}]}}}

Because converting lhs into this style is not always possible. Consider more complex example:

"anyOf": [
    {"properties": {"foo": {"type": "integer"}, "bar": {"type": "integer"}}},
    {"properties": {"foo": {"type": "integer"}, "bar": {"type": "string"}}},
    {"properties": {"foo": {"type": "string"}, "bar": {"type": "integer"}}},
]

In this case, foo can be string only if bar is integer. Thus we are not able to write like

{"properties": {"foo": {"anyOf": [???]}, "bar": {"anyOf": [???]}}}

[6293]

Better conversion would be from rhs to lhs. e.g.

"anyOf": [{
    "properties": {
        "foo": {
            "type": ["integer", "string"]
        },
        "bar": {
            "type": ["integer", "string"]
        }
    }
}]

to

"anyOf": [
    {"properties": {"foo": {"type": "integer"}, "bar": {"type": "integer"}}},
    {"properties": {"foo": {"type": "integer"}, "bar": {"type": "string"}}},
    {"properties": {"foo": {"type": "string"}, "bar": {"type": "integer"}}},
    {"properties": {"foo": {"type": "string"}, "bar": {"type": "string"}}},
]

[untitaker]

a fun problem to think about :) i am not sure if it is worth solving. if we go with the conversion from rhs to lhs as per your last comment, we should have some sort of limit in place to prevent combinatorial explosion and OOM. some good performance tests would be in https://github.com/getsentry/sentry-kafka-schemas/