Support customizing rejections for #[derive(TypedPath)]

[davidpdrsn]

Previously #[derive(TypedPath)] would always use PathRejection as the rejection type. Your only way to customize that was using Result<YourPath, PathRejection> in the handler, which is annoying if you're using it in multiple places.

This makes it possible to use your own rejection instead:

#[derive(TypedPath, Deserialize)]
#[typed_path("/users/:id", rejection(UsersMemberRejection))]
struct UsersMember {
    id: String,
}

struct UsersMemberRejection;

// Your rejection type must implement `From<PathRejection>`.
//
// Here you can grab whatever details from the inner rejection
// that you need
impl From<PathRejection> for UsersMemberRejection {
    fn from(rejection: PathRejection) -> Self {
        // ...
    }
}

// And your rejection must implement `IntoResponse`, like all rejections
impl IntoResponse for UsersMemberRejection {
    fn into_response(self) -> Response {
        // ...
    }
}

[takkuumi]

So excited, I am not sure could implement like this?

#[derive(TypedPath, Deserialize)]
#[typed_path("/users/:id", rejection("the path param for id `{0}` is not a number"))]
struct UsersMember {
    id: String,
}

[davidpdrsn]

@NateLing Not quite. Path has more failure cases than that and you'd have to handle all them:

impl From<PathRejection> for UsersMemberRejection {
    fn from(rejection: PathRejection) -> Self {
        match rejection {
            PathRejection::FailedToDeserializePathParams(inner) => match inner.into_kind() {
                // what do you want to do for each of these?
                ErrorKind::WrongNumberOfParameters { got, expected } => ...,
                ErrorKind::ParseErrorAtKey { key, value, expected_type } => ...,
                ErrorKind::ParseErrorAtIndex { index, value, expected_type } => ...,
                ErrorKind::ParseError { value, expected_type } => ...,
                ErrorKind::InvalidUtf8InPathParam { key } => ...,
                ErrorKind::UnsupportedType { name } => ...,
                ErrorKind::Message(_) => ...,
                _ => ...,
            },
            PathRejection::MissingPathParams(inner) => ...,
            _ => ...,
        }
    }
}