21 releases (5 breaking)
0.6.0 | Nov 29, 2022 |
---|---|
0.5.2 | Nov 16, 2022 |
0.4.1 | Aug 24, 2022 |
0.3.2 | Aug 5, 2022 |
0.1.4 | Mar 25, 2022 |
#916 in HTTP server
32 downloads per month
Used in 2 crates
69KB
1.5K
SLoC
Resp Result
Help data structure for web framework response
Why
Result
will become500
using as web framework response type whenErr(_)
, the action usually not I expect- using non-Result type as web framework response type cannot using
?
, the code will fill withif let
ormatch
that why I need a RespResult
, which can
- control respond code or other message when it become
RespResult::Err
, not always500
- impl the
Try
thus can using friendly?
to simplify code
note: because the
Try
not stable yet, this crate needNightly
rust
Usage
Install
add resp-result
into your crate
[dependencies]
resp-result = "*"
feature flags
-
for-axum
: enable axum support, that will implIntoResponse
forRespResult
-
for-actix
eable actix-web support, that will implResponder
forRespResult
-
extra-error
: enable extra error message in traitRespError
-
tracing
: enable recorder using tracing -
axum-full
: equal tofor-axum
+extra-error
-
actix-full
: equal tofor-actix
+extra-error
-
nightly_try_v2
: implTry
forRespResult
making it can using?
, it will enable feature try_trait_v2 and require Nightly rust compiler
Define an Error
RespResult<T,E>
require the E
impl the RespError
for example
use resp_result::{RespError, RespResult};
use std::borrow::Cow;
use http::StatusCode;
pub struct PlainError(String);
impl RespError for PlainError{
fn log_message(&self) -> Cow<'_, str> {
Cow::Owned(format!("PlainError: {}", self.0))
}
fn resp_message(&self) -> Cow<'_, str> {
"PlainError".into()
}
fn http_code(&self) -> StatusCode {
StatusCode::BAD_REQUEST
}
type ExtraMessage = String;
fn extra_message(&self) -> Self::ExtraMessage {
self.0.clone()
}
}
/// this can be use as handler return type
type PlainRResult<T> = RespResult<T, PlainError>;
Bound of T
in RespResult<T, E>
The T
require implement Serialize
and has 'static
lifetime
Using it
the following is an example for using RespResult
use resp_result::{RespError, RespResult};
use std::borrow::Cow;
use http::StatusCode;
pub struct PlainError(String);
impl RespError for PlainError{
fn log_message(&self) -> Cow<'_, str> {
Cow::Owned(format!("PlainError: {}", self.0))
}
type ExtraMessage = String;
fn extra_message(&self) -> Self::ExtraMessage {
self.0.clone()
}
}
/// this can be use as handler return type
type PlainRResult<T> = RespResult<T, PlainError>;
pub async fn welcome_short_name(name: String) -> PlainRResult<String>{
if name.len() >= 8{
// you can using `?` just like the function that return `Result`
Err(PlainError("the name size great then 8".to_string()))?;
}
if name.len() >= 4 {
// `Result::Ok` can convert into `RespResult::Success` just using `into`
Ok(format!("welcome! {name} with size great then 4")).into()
}else{
// or just direct using `RespResult::ok`
RespResult::ok(format!("welcome! {name}"))
}
}
ExtraFlag and ExtraFlags
In general the RespResult::Success
is always generate response with status code 200 OK
and using serde_json
serialize the body into json. But sometimes we want return an
304 Not Modified
with empty body to tell the client the resource do not change. To support above using situation, comes out the ExtraFlag
and ExtraFlags
Extra Flag
extra flag have 4 different type can bring different effect on response
empty_body
: this flag will stopRespResult
perform serialize into response bodystatus
: this flag will overwriteStatusCode
of responseset-header
: this flag will insert or append provide header into response header mapremove-header
: this flag will remove header from response header map
different extra flags can using +
to combine effect or +=
to adding effect
Extra Flags
extra flags is a set of extra flag
FlagWrap
flag wrap provide a wrap to send extra flag
when using extra flag, you need change return type from RespResult<T, E>
to RespResult<FlagWrap<T>, E>
the follow example change Status Code to 404 Not Found
use resp_result::{RespError, RespResult, FlagWrap, ExtraFlag};
use std::borrow::Cow;
use http::StatusCode;
pub struct PlainError(String);
impl RespError for PlainError{
fn log_message(&self) -> Cow<'_, str> {
Cow::Owned(format!("PlainError: {}", self.0))
}
type ExtraMessage = String;
fn extra_message(&self) -> Self::ExtraMessage {
self.0.clone()
}
}
/// this can be use as handler return type
type PlainRResult<T> = RespResult<T, PlainError>;
pub async fn welcome_short_name(
name: String,
) -> PlainRResult<FlagWrap<String>>{
if name.len() >= 8{
RespResult::ok(
format!("welcome! {name} your name size is {}",name.len()))
// using `with_flags` to covert RespResult<T, E>
// to `RespResult<FlagWrap<T>, E>`
// using `()` for no extra flags
.with_flags(())
}else{
// suing `flag_ok` direct construct a flag with resp result
RespResult::flag_ok(
format!("Welcome! {name}"),
ExtraFlag::status(StatusCode::NOT_FOUND)
)
}
}
Effect RespResult
behavior
by default the RespResult
will serialize the response body like that
{
"is-ok": true,
"error-message": "...",
"extra-msg": "...",
"body": null
}
the default behavior can be changed by using set_config
to set global configuration
for example, by config, we can change response body into following
{
"status": "fail",
"reterror": 10001,
"message": "something wrong",
"body": null
}
Dependencies
~2–13MB
~168K SLoC