New, flattened lottie schema doesn't work: 'if/then/else schemas are not supported'

[nuzzles]

Due to the problem in #907 reported, I requested a new flattened schema from the lottie team.

They actually made a new format to be compliant with type generators, that conversation happened here: lottie/lottie-spec#157

However, unfortunately, it looks like there's another issue.

Can

  --- stderr

  thread 'main' (531858) panicked at /home/robo/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typify-impl-0.5.0/src/merge.rs:293:9:
  not implemented: if/then/else schemas are not supported

Is this a case where the lottie team would need to make more changes or is this something that can be fixed on the typify side?

[ahl]

This can be fixed in typify; we just haven't had a need to yet. Here's one of the schemas:

        "assets__image": {
            "type": "object",
            "title": "Image",
            "description": "Asset containing an image that can be referenced by layers.",
            "allOf": [
                {
                    "$ref": "#/$defs/assets__asset"
                },
                {
                    "$ref": "#/$defs/helpers__slottable-object"
                },
                {
                    "type": "object",
                    "properties": {
                        "w": {
                            "title": "Width",
                            "description": "Width of the image",
                            "type": "number"
                        },
                        "h": {
                            "title": "Height",
                            "description": "Height of the image",
                            "type": "number"
                        },
                        "p": {
                            "title": "File Name",
                            "description": "Name of the image file or a data url",
                            "type": "string"
                        },
                        "u": {
                            "title": "File Path",
                            "description": "Path to the image file",
                            "type": "string"
                        },
                        "e": {
                            "title": "Embedded",
                            "description": "If '1', 'p' is a Data URL",
                            "$ref": "#/$defs/values__int-boolean"
                        }
                    },
                    "allOf": [
                        {
                            "if": {
                                "properties": {
                                    "e": {
                                        "const": 1
                                    }
                                },
                                "required": [
                                    "e"
                                ]
                            },
                            "then": {
                                "properties": {
                                    "p": {
                                        "$ref": "#/$defs/values__data-url"
                                    }
                                }
                            }
                        }
                    ],
                    "if": {
                        "required": [
                            "sid"
                        ]
                    },
                    "else": {
                        "required": [
                            "w",
                            "h",
                            "p"
                        ]
                    }
                }
            ]
        },
        "assets__asset": {
            "type": "object",
            "title": "Asset",
            "allOf": [
                {
                    "$ref": "#/$defs/helpers__visual-object"
                },
                {
                    "type": "object",
                    "properties": {
                        "id": {
                            "title": "ID",
                            "description": "Unique identifier used by layers when referencing this asset",
                            "type": "string"
                        }
                    },
                    "required": [
                        "id"
                    ]
                }
            ]
        },

Simplifying a bit:

{
        "assets__image": {
            "type": "object",
            "allOf": [
                {
                    "type": "object",
                    "properties": {
                        "w": {
                            "type": "number"
                        },
                        "h": {
                            "type": "number"
                        },
                        "p": {
                            "type": "string"
                        },
                        "u": {
                            "type": "string"
                        },
                        "e": {
                            "type": "integer"
                        },
                        "sid": {
                            "type": "string"
                        }
                    },
                    "allOf": [
                        {
                            "if": {
                                "properties": {
                                    "e": {
                                        "const": 1
                                    }
                                },
                                "required": [
                                    "e"
                                ]
                            },
                            "then": {
                                "properties": {
                                    "p": {
                                        "$ref": "#/$defs/values__data-url"
                                    }
                                }
                            }
                        }
                    ],
                    "if": {
                        "required": [
                            "sid"
                        ]
                    },
                    "else": {
                        "required": [
                            "w",
                            "h",
                            "p"
                        ]
                    }
                }
            ]
        }
}

In plain language:

• if the object has a property called e with a value of 1 then the value of the property p must be a URL
• either the object needs to have a property called sid or it needs to have properties w, h, and p

That first constraint is a little tricky to model in Rust--I'm pretty sure you can't do it without a custom Serialize/Deserialize implementation. The second constraint seems a little surprising only in that sid and (w, h, p) aren't mutually exclusive--you can e.g. have sid and p, and I'm not sure what that means semantically.

In any case, I believe that if/then/else can be rewritten as oneOf:

{
    "$defs": {
        "assets__image": {
            "type": "object",
            "allOf": [
                {
                    "type": "object",
                    "properties": {
                        "w": {
                            "type": "number"
                        },
                        "h": {
                            "type": "number"
                        },
                        "p": {
                            "type": "string"
                        },
                        "u": {
                            "type": "string"
                        },
                        "e": {
                            "type": "integer"
                        },
                        "sid": {
                            "type": "string"
                        }
                    },
                    "allOf": [
                        {
                            "oneOf": [
                                {
                                    "properties": {
                                        "e": {
                                            "const": 1
                                        },
                                        "p": {
                                            "$ref": "#/$defs/values__data-url"
                                        }
                                    },
                                    "required": [
                                        "e"
                                    ]
                                },
                                {
                                    "not": {
                                        "e": {
                                            "const": 1
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            "oneOf": [
                                {
                                    "required": [
                                        "sid"
                                    ]
                                },
                                {
                                    "not": {
                                        "required": [
                                            "sid"
                                        ]
                                    },
                                    "required": [
                                        "w",
                                        "h",
                                        "p"
                                    ]
                                }
                            ]
                        }
                    ]
                }
            ]
        }
    }
}

The modeling of this in Rust is pretty tricky because the two oneOfs (or if/thens) overlap (i.e. they both involve p) so I think the best we could do is some sort of 4-variant enum:

pub enum Image {
    ETrueSid {
        w: Option<f64>,
        h: Option<f64>,
        p: Option<Url>,
        u: Option<String>,
        e: ValueOne
        sid: String,
    },
    ETrueWhp {
        w: f64,
        h: f64,
        p: Url,
        u: Option<String>,
        e: ValueOne
    },

    EFalseSid {
        w: Option<f64>,
        h: Option<f64>,
        p: Option<String>,
        u: Option<String>,
        e: Option<ValueAnythingButOne>,
        sid: String,
    },
    EFalseWhp {
        w: f64,
        h: f64,
        p: String,
        u: Option<String>,
        e: Option<ValueAnythingButOne>,
    },
}

I think this is pretty terrible, but maybe it's the best we can do. Do you have a suggestion for how you might prefer to see this modeled?

One option for getting by this error is to use the replace imperative and define your own type.

[nuzzles]

(for reference, I am trying to use Typify to generate bindings for a Lottie renderer, I am not on the lottie team).

I would prefer as a user that if/else would map to oneOf if it can, or more directly, an Enum in Rust. I don't exactly mind how bad the output is because my objective is type-safe first, human readable second.

I think your question has another part, aimed towards @b-wils, who made the schema changes: Is it possible to change the if/else conditionals to oneOf? That would play with type generators better.

[ahl]

Well, my proximate question is for you: how would you like this type modeled? (and: would replace let you get past this hurdle in the near term?)

With regard to oneOf vs. if/then[/else]. I think it's very likely that oneOf more closely models the intention, but if they're happy with the if/then... it's their schema, so: sure!

[nuzzles]

Well, my proximate question is for you: how would you like this type modeled? (and: would replace let you get past this hurdle in the near term?)

With regard to oneOf vs. if/then[/else]. I think it's very likely that oneOf more closely models the intention, but if they're happy with the if/then... it's their schema, so: sure!

I'm not looking to bandaid the schema with a replace or any arcane scripting in the schema generation. This is because I want to future-proof it, and if the schema changes, our type generator will break.

Ideally I want a no-issue type generated binding, and then the issues with the generated bindings can be abstracted out, which we already do.

P.S. Sorry for the late reply, @ahl !

[ahl]

Sounds good, @nuzzles. What would you like the generated type to look like?

[nuzzles]

Sounds good, @nuzzles. What would you like the generated type to look like?

If you're referring to if/then/else, I guess an enum? I'm not picky, as long as it works.