forked from jmug/stoatchat
102 lines
3.2 KiB
Rust
102 lines
3.2 KiB
Rust
use std::fmt::Debug;
|
|
|
|
use revolt_rocket_okapi::{
|
|
r#gen::OpenApiGenerator,
|
|
request::OpenApiFromData,
|
|
response::OpenApiResponderInner,
|
|
revolt_okapi::openapi3::{RequestBody, Responses}, util::add_schema_response
|
|
};
|
|
use rocket::{data::{Data, FromData, Limits, Outcome}};
|
|
use rocket::response::{self, Responder, content};
|
|
use rocket::request::{local_cache, Request};
|
|
use schemars::JsonSchema;
|
|
use serde::{Deserialize, Serialize};
|
|
use revolt_result::{create_error, Error, ToRevoltError};
|
|
|
|
// A lot of this code is modified versions of rocket::serde::json so we can store
|
|
// the error so it can be passed to the error catcher.
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct Json<T>(pub T);
|
|
|
|
impl<'r, T: Deserialize<'r>> Json<T> {
|
|
#[inline]
|
|
pub fn into_inner(self) -> T {
|
|
self.0
|
|
}
|
|
|
|
fn from_str(s: &'r str) -> Result<Self, Error> {
|
|
serde_json::from_str(s)
|
|
.map(Json)
|
|
.map_err(|e| create_error!(DeserializationError { error: e.to_string() }))
|
|
}
|
|
|
|
async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Result<Self, Error> {
|
|
let limit = req.limits().get("json").unwrap_or(Limits::JSON);
|
|
let string = match data.open(limit).into_string().await {
|
|
Ok(s) if s.is_complete() => s.into_inner(),
|
|
Ok(_) => {
|
|
return Err(create_error!(PayloadTooLarge));
|
|
},
|
|
Err(_) => return Err(create_error!(IOError)),
|
|
};
|
|
|
|
Self::from_str(local_cache!(req, string))
|
|
}
|
|
}
|
|
|
|
impl<T> std::ops::Deref for Json<T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl<'r, T: Deserialize<'r> + std::fmt::Debug> FromData<'r> for Json<T> {
|
|
type Error = Error;
|
|
|
|
async fn from_data(req: &'r Request<'_>, data: Data<'r>) -> Outcome<'r, Self> {
|
|
let r = Self::from_data(req, data).await;
|
|
|
|
match r {
|
|
Ok(value) => Outcome::Success(value),
|
|
Err(e) => {
|
|
req.local_cache(|| Some(e.clone()));
|
|
rocket::outcome::Outcome::Error((e.rocket_status(), e))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'r, T: Serialize> Responder<'r, 'static> for Json<T> {
|
|
fn respond_to(self, req: &'r Request<'_>) -> response::Result<'static> {
|
|
match serde_json::to_string(&self.0).capture_error() {
|
|
Ok(string) => content::RawJson(string).respond_to(req),
|
|
Err(_) => create_error!(InternalError).respond_to(req)
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'r, T: JsonSchema + Deserialize<'r> + Debug> OpenApiFromData<'r> for Json<T> {
|
|
fn request_body(gen: &mut OpenApiGenerator) -> revolt_rocket_okapi::Result<RequestBody> {
|
|
crate::fn_request_body!(gen, T, "application/json")
|
|
}
|
|
}
|
|
|
|
impl<T: JsonSchema + Serialize> OpenApiResponderInner for Json<T> {
|
|
fn responses(gen: &mut OpenApiGenerator) -> revolt_rocket_okapi::Result<Responses> {
|
|
let mut responses = Responses::default();
|
|
let schema = gen.json_schema::<T>();
|
|
add_schema_response(&mut responses, 200, "application/json", schema)?;
|
|
Ok(responses)
|
|
}
|
|
}
|
|
|
|
impl<T: validator::Validate> validator::Validate for Json<T> {
|
|
fn validate(&self) -> Result<(), validator::ValidationErrors> {
|
|
self.0.validate()
|
|
}
|
|
}
|