Trait bounds

[jb-alvarado]

Hello,

I would like to export a struct that includes some trait bounds, that TS doesn't support. My struct looks like this:

#[derive(Clone, Debug, Deserialize, Serialize, TS)]
#[ts(export, export_to = "query.d.ts", bound = "T: TS")]
pub struct QueryObj<T: FromStr + strum::IntoEnumIterator + StrCompare + TS> {
    #[serde(default)]
    pub path: String,

    #[serde(default)]
    pub query: String,

    #[serde(default = "default_limit")]
    pub limit: i64,

    #[serde(default)]
    pub offset: i64,

    #[serde(
        default = "default_fields",
        deserialize_with = "split_string_to_fields"
    )]
    #[ts(as = "String")]
    pub fields: Vec<T>,
}

From the compiler I get the message, that FromStr etc. are not implemented for Dummy.

Can someone give me a hint on how to solve this?

[NyxCode]

Hey!
You will need to just remove the trait bounds from the struct, and add them where they are actually needed (impl blocks, generic functions, etc.). This is also the generally accepted guidance, see e.g. here.

While I strongly agree with that guidance, I'd prefer if we didn't force people to follow it. There are some technical challenges, however, that make this difficult. For your struct, ts-rs will generate an impl<T> TS for QueryObj<T> { .. } block, which contains the code to generate bindings for a concrete type (e.g QueryObj<String>). To then generate a generic TypeScript type, we use a dummy type as generic parameter. That is the step that fails, because it does not satisfy your trait bounds.
Not much effort has been put into removing this limitation, because the reason mentioned above. Trait bounds on a struct are almost never needed, and when they are (e.g. when using associated types), you can't generate a generic typescript binding anyway and need to use #[ts(concrete)].

[jb-alvarado]

Thank you @NyxCode for your explanation! In my case I did not fund a solution, to remove the bounds. I set defaults and de-serialize with:

 /// When no fields are set, collect all fields from given Enum
fn default_fields<T>() -> Vec<T>
where
    T: strum::IntoEnumIterator + StrCompare,
{
    T::iter()
        .filter(|f| !f.is_equal_to_str("count"))
        .collect::<Vec<_>>()
}

/// Helper function, to transform strings to array of Enum
pub fn split_string_to_fields<'de, D, T>(deserializer: D) -> Result<Vec<T>, D::Error>
where
    D: Deserializer<'de>,
    T: FromStr + strum::IntoEnumIterator + StrCompare,
{
    let s: String = Deserialize::deserialize(deserializer)?;
    let mut l = s
        .split(',')
        .filter_map(|s| T::from_str(s.trim()).ok())
        .collect::<Vec<T>>();

    Ok(l)
}

And one of my T are like:

#[derive(Debug, Default, Serialize, Deserialize, Clone, Eq, PartialEq, EnumIter, TS)]
#[serde(rename_all = "snake_case")]
pub enum LocaleFields {
    ID,
    #[default]
    Code,
    Name,
}

impl StrCompare for LocaleFields {
    fn is_equal_to_str(&self, other: &str) -> bool {
        match self {
            Self::ID => other == "id",
            Self::Code => other == "code",
            Self::Name => other == "name",
        }
    }
}

I tried also #[ts(concrete)] but maybe not correctly.

[NyxCode]

So the issue is that you need the bounds for serde? Could you remove them from the struct itself, and use #[serde(bound)]? There are some examples for that here.

[jb-alvarado]

Ah, thanks - that works! I didn't know I can apply this directly to a struct field.