Parsing a request into a single type

[Kinrany]

Here's an API I keep looking for: you specify a single MyRequest type, you annotate it with #[derive(FromRequest, IntoRequest)], you annotate the contents with attributes that specify the way the type should be converted into HTTP requests and parsed back (like whether it should be parsed from resource name, from query string, from JSON body, etc.), and you're done.

So instead of mixing the parsing logic with the handling logic in handler functions you write a single framework-agnostic Rust type, you annotate it with macros using the framework, and then you write a single framework-agnostic handler function that gets a single Rust type as input.

Sounds viable? Any previous discussions I should be aware of?

[davidpdrsn]

Do you mean to inspect the content type and parse things based on that, without requiring a specific type?

[Kinrany]

I'm not sure I understand the question, sorry. This would indeed allow writing your own Json type.

[davidpdrsn]

In that case I don't understand what you mean 😅 can you show some example code?

[Kinrany]

I'm going to wildly gesture in the direction of the thing and won't attempt to design a working API.

#[derive(Request)]
#[req(Json)] // fields sent as JSON by default
struct PostMessage {
    /// Provide a unique ID to make the command idempotent
    #[req(QueryParam)] // sent as a query string parameter
    nonce: Option<Uuid>,
    #[req(BasicAuth)] // sent as a basic auth header (but seems tricky to do both serialization and deserialization)
    user_id: String,

    // sent as JSON fields
    message_text: String,
    reply_to: UserId,
}

#[derive(Response)]
enum PostMessageResponse {...}

/// Handle an incoming command and return its result
async fn handler(req: PostMessage) -> PostMessageResponse {...}

/// Send message over HTTP and parse the response
async fn send_message_over_http(req: PostMessage) -> PostMessageResponse {...}

I guess this starts looking a lot like tower::Service? And then you could say that what I'm looking for is an ergonomic way of defining:

1. Conversion of types from and into HTTP (or other transport) request and response types
2. Services that send and receive these types

[davidpdrsn]

Thanks! That clears things up!

With #[derive(FromRequest)] that we have today you can get part of the way there:

use axum::{
    async_trait,
    extract::{rejection::QueryRejection, FromRequest, FromRequestParts, Query},
    http::request::Parts,
    response::{IntoResponse, Response},
    RequestPartsExt,
};
use serde::Deserialize;
use uuid::Uuid;

fn main() {}

#[derive(FromRequest)]
struct PostMessageRequest {
    nonce: Option<Nonce>,
    user_id: UserId,
    message_text: String,
}

struct PostMessageResponse {}

impl IntoResponse for PostMessageResponse {
    fn into_response(self) -> Response {
        // or whatever you want
        ().into_response()
    }
}

#[derive(Deserialize)]
struct Nonce {
    id: Uuid,
}

#[async_trait]
impl<S> FromRequestParts<S> for Nonce
where
    S: Send + Sync,
{
    type Rejection = QueryRejection;

    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self, Self::Rejection> {
        parts.extract::<Query<Self>>().await.map(|query| query.0)
    }
}

struct UserId(Uuid);

#[async_trait]
impl<S> FromRequestParts<S> for UserId
where
    S: Send + Sync,
{
    type Rejection = std::convert::Infallible;

    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
        // not sure how to parse a user id from basic auth
        todo!()
    }
}

async fn send_message_over_http(req: PostMessageRequest) -> PostMessageResponse {
    PostMessageResponse {}
}

I think the sort of macro you're describing is perhaps a little too opinionated for axum and probably makes most sense in a separate crate.

[Kinrany]

Thanks! Yeah, FromRequest and extractors are the things that inspired this.

Totally understand that this would be a huge change for axum. I'm mostly wondering if this is something people considered and talked about before.