Is it possible to type fields as arbitrary JSON values (e.g. with serde_json::Value)?

[rossng]

I would like to include an arbitrary JSON blob in my API schema. Something like this:

#[derive(Serialize, Deserialize, ToSchema, Clone)]
pub struct Input {
    name: String,
    blob: serde_json::Value,
}

This doesn't immediately work. Since serde_json::Value doesn't implement ToSchema, the blob property ends up with this type in the OpenAPI schema:

"config": {
    "$ref": "#/components/schemas/serde_json.Value"
}

The best solution I have been able to find is this:

#[derive(Serialize, Deserialize, ToSchema, Clone)]
pub struct Input {
    name: String,
    #[schema(value_type = Object)]
    blob: serde_json::Value,
}

But this isn't ideal as it doesn't support other valid JSON values like arrays, strings etc.

I've had a look at the macro documentation and ToSchema implementation guide, but I haven't been able to figure out how to make this work. Would appreciate any ideas!

[juhaku]

This is a bit problematic since the serde_json::Value is a dynamic type. In compile time there is no access to the actual type implementation of the serde_json::Value consequently it is not possible to know what kind of schema should be generated.

The only option is to use the value_type attribute but instead of just defining Object you can also use any Rust types as well. E.g. you could define a vec of Objects.

#[derive(Serialize, Deserialize, ToSchema, Clone)]
pub struct Input {
    name: String,
    #[schema(value_type = Vec<Object>)]
    blob: serde_json::Value,
}

Thing is that with serde_json::Value you can define at runtime what the value is and the schema for the type is generated compile time. The schema that the API should return must be know beforehand. Otherwise it only can be expected that the value is a generic Open API object.

Another alternative is to use generics. Because you need to define all possible schemas beforehand and the generics would allow you to do so.

#[derive(ToSchema)]
#[aliases(ValueInt = Value<i32>, ValueString = Value<String>)]
struct Value<T> {
    value: T
}

#[derive(OpenApi)]
#[openapi(components(schemas(ValueInt, ValueString)))]
struct Doc;

[rossng]

Thanks for the detailed response. For now I've decided to just serialise the JSON to a string, so immediate problem solved.

I can see why it's a fiddly problem to solve. Looking at the SchemaType enum, there is no way to implement ToSchema such that it would build a schema like this, since the SchemaType must explicitly be one of Object, String etc.

I'm not that familiar with utoipa's internals but I do wonder if an extra option could be added to that enum to make it possible to express schemas that are not explicitly typed. It's not a pressing need for me now, so I won't look into implementing anything yet - but if it does become a problem I might come back to it later.