Bypass Parameter Type and URL Encoding for uri! Macro

[KartikSoneji]

The uri! macro is great for constructing typesafe urls but at times it's useful to be able to bypass the type restrictions or the URL Encoding of the values.

My particular usecase is there is a third party service that expects callback URLs of the form
https://example.com/?a={data1}&b={data2}
where {data1} and {data2} are placeholders that the service fills in before making the callback.

Now the issue is the service needs those placeholders to exactly match the format of {identifier}.
URL encoding as %7Bidentifier%7D does not work.
Additionally, non-string parameters can't even accept "{identifier}".

One workaround I'm experimenting with is creating a struct that implements FromUriParam and UriDisplay.

use rocket::http::{
    uri::fmt::Query,
    uri::fmt::{Formatter, FromUriParam, UriDisplay},
};

pub struct QueryParameterPlaceholder<'a>(pub &'a str);

impl UriDisplay<Query> for QueryParameterPlaceholder<'_> {
    fn fmt(&self, f: &mut Formatter<Query>) -> std::fmt::Result {
        f.write_raw(format!("{{{}}}", self.0))
    }
}

impl<'a> FromUriParam<Query, QueryParameterPlaceholder<'a>> for u32 {
    type Target = QueryParameterPlaceholder<'a>;
    fn from_uri_param(param: Self::Target) -> Self::Target {
        param
    }
}

Usage:

uri!(route_name(
    parameter = QueryParameterPlaceholder("param1")
));

I can't seem to make the implementation generic for all types or over Path and Query, but that might be because of my limited rust knowledge.
(Maybe it's better to add another trait, UriRawDisplay, implement it for the same types as UriDisplay, and allow other structs to implement as needed)

It also isn't the cleanest implementation, I would prefer an extension to the macro, similar to _ for default fields.
For example something like

# named
uri!(route_name(
    parameter = raw{"{param1}"}
));

# unnamed
uri!(route_name(
    raw{"{param1}"}
));

(raw{} over raw() since it avoids the issue of having an in-scope function that happens to be named raw)

[the10thWiz]

First, I took a stab at making your example code generic over the inner type, and work for both path and query.

use rocket::{
    http::{
        impl_from_uri_param_identity,
        uri::fmt::{Formatter, FromUriParam, Part, UriDisplay},
    },
    request::FromParam,
};
use std::fmt::Display;

pub struct QueryParameterPlaceholder<T>(pub T);

impl<T: Display> Display for QueryParameterPlaceholder<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{{{}}}", self.0)
    }
}

impl<P: Part, T: Display> UriDisplay<P> for QueryParameterPlaceholder<T> {
    fn fmt(&self, f: &mut Formatter<P>) -> std::fmt::Result {
        f.write_raw(format!("{{{}}}", self.0))
    }
}

impl_from_uri_param_identity!((T: Display) QueryParameterPlaceholder<T>);

impl<'a, T: FromParam<'a> + Display> FromParam<'a> for QueryParameterPlaceholder<T> {
    type Error = T::Error;

    fn from_param(param: &'a str) -> Result<Self, Self::Error> {
        T::from_param(param).map(Self)
    }
}
#[get("/<code>")]
fn code(code: QueryParameterPlaceholder<&str>) {}

fn tmp() {
    let _ = uri!(code(QueryParameterPlaceholder("data")));
}

I don't know if it meets your use-case, but it should at least point you in the right direction.

Second, I do agree that it might be useful to add support for this to the macro. This isn't likely to land before 0.6 (which already has a ton of breaking changes), so I'd recommend going with the work-around for now. Looking at the syntax, I think it makes sense to use raw strings, like r"{param1}", since the whole point is they don't get escaped.

[KartikSoneji]

Hi, thanks for the quick reply!

#[get("/<code>")]
fn code(code: QueryParameterPlaceholder<&str>) {}

Ah sorry should have been more clear in my post.
The idea is to not change the type of the route parameters, and also use this for non-string types.
The inner type should always be &str.

So the route would look like

// custom type AccessToken that implements FromParam and performs validation

#[get("/callback?<a>&<b>")]
fn callback(token: AccessToken, data: u32) {}

And it could be used like

uri!(code(
    token = QueryParameterPlaceholder("token"),
    data = QueryParameterPlaceholder("data"),
));
// would output /code?token={token}&data={data}

I was running into issues making the implementation generic for all traits:

impl<'a, T> FromUriParam<Query, QueryParameterPlaceholder<'a>> for T {

I think it makes sense to use raw strings, like r"{param1}", since the whole point is they don't get escaped.

I did consider that too, but:

• There are legitimate use-cases to use raw string literals to keep the code clean while still having rocket handle url escaping
• It would not follow the principle of least surprise, since

  // no url encoding
  uri!(route(param = r"{}"))
  
  // url encoding, unexpected
  let param = r"{}";
  uri!(route(param = param))

• And finally it would limit this to raw string literals, raw{variable} would not work.

[the10thWiz]

impl<'a, T> FromUriParam<Query, QueryParameterPlaceholder<'a>> for T {

You can't write this impl, because it the orphan rule. Basically, you can only implement a trait if you're in the same module as either the trait or the type you're implementing on. The means blanket implementations (like above) can only be placed in the same module as the trait itself.

In your case, you're going to have to either change the type in the route, or work directly with the URI (losing the type safety). If you're interested, a RawComponent wrapper type or improvements to the uri macro would be welcome as PRs.

[KartikSoneji]

I'll be happy to take a crack at adding the raw{""} modifier to the uri macro, do you think it should be a separate trait? Something like UriRawDisplay? Or should it just accept anything with Display?

[the10thWiz]

I'd just go with Display for now, but we can refine this later.