Struct Json 

pub struct Json<T>(pub T);

A JSON extractor and responder.

Json<T> wraps any value T and grants it two complementary roles inside a Churust handler:

As an extractor (handler argument)

When placed as the last handler argument, Json<T> reads the entire request body and attempts to deserialize it as JSON into T. T must implement serde::de::DeserializeOwned.

The request must declare a JSON content type — application/json, or any +json structured suffix. Anything else is 415 Unsupported Media Type, which is what keeps a cross-origin HTML form (whose three possible content types send no CORS preflight) from reaching a JSON handler with the visitor’s cookies attached.

If the body is missing or malformed the framework returns an HTTP 400 Bad Request response automatically — the handler is never called.

use churust_core::{Churust, TestClient};
use churust_json::Json;
use serde::Deserialize;

#[derive(Deserialize)]
struct CreateUser { username: String }

let app = Churust::server()
    .routing(|r| {
        r.post("/users", |Json(body): Json<CreateUser>| async move {
            format!("created {}", body.username)
        });
    })
    .build();

let res = TestClient::new(app)
    .post("/users")
    .header("content-type", "application/json")
    .body(r#"{"username":"bob"}"#)
    .send()
    .await;
assert_eq!(res.status().as_u16(), 200);

As a responder (return value)

Wrapping any T: Serialize in Json and returning it from a handler serializes T to JSON and sets the Content-Type header to application/json.

If serialization fails at runtime (extremely rare for well-formed types) the framework returns an HTTP 500 Internal Server Error.

use churust_core::{Churust, Call, TestClient};
use churust_json::Json;
use serde::Serialize;

#[derive(Serialize)]
struct Status { ok: bool }

let app = Churust::server()
    .routing(|r| {
        r.get("/status", |_c: Call| async { Json(Status { ok: true }) });
    })
    .build();

let res = TestClient::new(app).get("/status").send().await;
assert_eq!(res.status().as_u16(), 200);
assert_eq!(res.header("content-type"), Some("application/json"));

Pattern destructuring

The inner value is accessed through .0 or via pattern destructuring:

use churust_json::Json;
use serde::Deserialize;

#[derive(Deserialize, Debug, PartialEq)]
struct Point { x: f64, y: f64 }

// Pattern destructuring extracts the inner value directly.
let Json(point) = Json(Point { x: 1.0, y: 2.0 });
assert_eq!(point, Point { x: 1.0, y: 2.0 });

Tuple Fields

0: T

The inner value being wrapped.

Access it with .0 or destructure: let Json(value) = json_wrapper;.

Trait Implementations

impl<T: Clone> Clone for Json<T>

fn clone(&self) -> Json<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Json<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> FromCall for Json<T>

where T: DeserializeOwned + Send,

fn from_call<'async_trait>( call: Call, ) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>>

where Self: 'async_trait,

Build Self by consuming the call, or return an Error (which the handler renders as the response).

impl<T> IntoResponse for Json<T>

where T: Serialize,

fn into_response(self) -> Response

Consume self and produce the Response to send.