derive that forwards From/ToBytes to specific encoding

[ModProg]

My idea was to add to extism_convert either derive macros for the different data formats, or a single Encoding derive macro, that specifies a specific one.

In:

#[derive(ToJson, FromJson)]
// or
#[derive(ToEncoding, FromEncoding)]
#[encoding(Json)]
struct Struct { /* some fields */ }

Out:

// ToJson
impl<'a> ToBytes<'a> for Struct {
  type Bytes = <Json<Self> as ToBytes<'a>>::Bytes;
  
  fn to_bytes(&self) -> Result<Self::Bytes, Error> {
    Json(self).to_bytes()
  }
}
// FromJson
impl FromBytesOwned for Struct {
  fn from_bytes_owned(date: &[u8]) -> Result<Self, Error> {
    Json::from_bytes_owned(data).map(|j| j.0)
  }
}

This allows using it directly as function arguments/return type, and it automatically has the correct encoding (e.g., when sharing code between host and plugin)

[zshipko]

Good idea! This would definitely reduce the amount of boilerplate when only one encoding is ever used for a type.

[ModProg]

I'd be up to look into implementing this, what would be your preferred API:

// require serde::{Serialize, DeserializeOwned}
#[derive(FromJson, ToJson)]
#[derive(FromMsgpack, ToMsgpack)]
// prost::Message
#[derive(FromProst, ToProst)]
// require bytemuck::Pod
#[derive(FromRaw, ToRaw)]

or

#[derive(FromBytes, ToBytes}
// require serde::{Serialize, DeserializeOwned}
#[encoding(Json)]
#[encoding(Msgpack)]
// prost::Message
#[encoding(Prost)]
// require bytemuck::Pod
#[encoding(Raw)]

[ModProg]

I would prefer the latter because I think it would enable us to create something quite flexible.

we could accept any generic tuple struct that implements ToBytes as argument to the encode attribute.

[zshipko]

I agree, I think the second option is preferred, we would just need to make sure that only one encoding type is specified.

Thanks for picking this up - let me know if you run into any issues!