Struct problem_details::ProblemDetails

pub struct ProblemDetails<Ext = ()> {
    pub type: Option<ProblemType>,
    pub status: Option<StatusCode>,
    pub title: Option<String>,
    pub detail: Option<String>,
    pub instance: Option<Uri>,
    pub extensions: Ext,
}

A RFC 9457 / RFC 7807 problem details object.

Creating problem details

You can create a new problem details from a given status code using ProblemDetails::from_status_code.

This will set the status field to the given status code, the title field to the canonical reason phrase of the status code, and the type field to none, which is equivalent to about:blank.

use http::StatusCode;
use problem_details::ProblemDetails;

let details = ProblemDetails::from_status_code(StatusCode::NOT_FOUND);

assert_eq!(details.status, Some(StatusCode::NOT_FOUND));
assert_eq!(details.title, Some("Not Found".to_string()));
assert_eq!(details.r#type.unwrap_or_default(), problem_details::ProblemType::default());

You can then use the builder pattern to add additional fields.

use http::{StatusCode, Uri};
use problem_details::ProblemDetails;

let details = ProblemDetails::from_status_code(StatusCode::NOT_FOUND)
   .with_type(Uri::from_static("example:type"))
   .with_title("There is something wrong");

assert_eq!(details.status, Some(StatusCode::NOT_FOUND));
assert_eq!(details.title, Some("There is something wrong".to_string()));
assert_eq!(details.r#type.unwrap_or_default(), Uri::from_static("example:type").into());

You can also create a new problem details object using ProblemDetails::new.

use http::Uri;
use problem_details::ProblemDetails;

let details = ProblemDetails::new()
  .with_type(Uri::from_static("example:type"))
  .with_title("There is something wrong");

assert_eq!(details.status, None);
assert_eq!(details.title, Some("There is something wrong".to_string()));
assert_eq!(details.r#type.unwrap_or_default(), Uri::from_static("example:type").into());

Extensions

To add extensions, you need to define a struct that holds the extension fields, and use this struct as the generic parameter for ProblemDetails<Ext>. Using with_extensions, the type is adjusted automatically for you.

Extension fields are flattened into the problem details object when serialized.

use problem_details::ProblemDetails;

struct MyExt {
    foo: String,
    bar: u32,
}

let details = ProblemDetails::new()
    .with_extensions(MyExt {
        foo: "Hello".to_string(),
        bar: 42,
    });

// details is of type ProblemDetails<MyExt>
let typecheck: ProblemDetails<MyExt> = details;

If you need dynamic extensions, you can use a HashMap as extensions object.

use std::collections::HashMap;
use problem_details::ProblemDetails;

let mut extensions = HashMap::<String, serde_json::Value>::new();
extensions.insert("foo".to_string(), serde_json::json!("Hello"));
extensions.insert("bar".to_string(), serde_json::json!(42));

let details = ProblemDetails::new()
   .with_extensions(extensions);

// details is of type ProblemDetails<HashMap<String, serde_json::Value>>
let typecheck: ProblemDetails<HashMap<String, serde_json::Value>> = details;

Fields

type: Option<ProblemType>

An optional uri describing the problem type.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-type for more information.

status: Option<StatusCode>

An optional status code for this problem.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-status for more information.

title: Option<String>

An optional human-readable title for this problem.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-title for more information.

detail: Option<String>

An optional human-readable description of this problem.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-detail for more information.

instance: Option<Uri>

An optional uri identifying the specific instance of this problem.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-instance for more information.

extensions: Ext

An object containing extensions to this problem details object.

Note that the extensions will be flattened into the resulting problem details representation.

See https://www.rfc-editor.org/rfc/rfc9457.html#name-extension-members for more information.

Implementations

impl ProblemDetails<()>

pub fn new() -> Self

Creates a new empty problem details object.

pub fn from_status_code(status: StatusCode) -> Self

Creates a new problem details object from a given status code.

This will set the status field to the given status code, the title field to the canonical reason phrase of the status code, and the type field to none, which is equivalent to about:blank.

impl<Ext> ProblemDetails<Ext>

pub fn with_type(self, type: impl Into<ProblemType>) -> Self

Builder-style method that sets the type field of this problem details object.

pub fn with_status(self, status: impl Into<StatusCode>) -> Self

Builder-style method that sets the status field of this problem details object.

pub fn with_title(self, title: impl Into<String>) -> Self

Builder-style method that sets the title field of this problem details object.

pub fn with_detail(self, detail: impl Into<String>) -> Self

Builder-style method that sets the detail field of this problem details object.

pub fn with_instance(self, instance: impl Into<Uri>) -> Self

Builder-style method that sets the instance field of this problem details object.

pub fn with_extensions<NewExt>( self, extensions: NewExt ) -> ProblemDetails<NewExt>

Builder style method that sets the extensions field of this probelm details object.

Trait Implementations

impl<Ext: Clone> Clone for ProblemDetails<Ext>

fn clone(&self) -> ProblemDetails<Ext>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Ext: Debug> Debug for ProblemDetails<Ext>

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

Formats the value using the given formatter.

impl<Ext: Default> Default for ProblemDetails<Ext>

fn default() -> ProblemDetails<Ext>

Returns the “default value” for a type.

impl<'de, Ext> Deserialize<'de> for ProblemDetails<Ext>

where Ext: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Ext> Display for ProblemDetails<Ext>

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

Formats the value using the given formatter.

impl<Ext> Error for ProblemDetails<Ext>

where Ext: Debug,

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type based access to context intended for error reports.

impl<Ext> From<JsonProblemDetails<Ext>> for ProblemDetails<Ext>

fn from(value: JsonProblemDetails<Ext>) -> Self

Converts to this type from the input type.

impl<Ext> From<ProblemDetails<Ext>> for JsonProblemDetails<Ext>

fn from(value: ProblemDetails<Ext>) -> Self

Converts to this type from the input type.

impl<Ext> From<ProblemDetails<Ext>> for XmlProblemDetails<Ext>

fn from(value: ProblemDetails<Ext>) -> Self

Converts to this type from the input type.

impl<Ext> From<XmlProblemDetails<Ext>> for ProblemDetails<Ext>

fn from(value: XmlProblemDetails<Ext>) -> Self

Converts to this type from the input type.

impl<Ext> IntoResponse for ProblemDetails<Ext>

where Ext: Serialize,

fn into_response(self) -> Response

Create a response.

impl<Ext> IntoResponse for ProblemDetails<Ext>

where Ext: Serialize + Send,

fn into_response(self) -> Response

Consume itself and return Response.

fn with_header<K, V>(self, key: K, value: V) -> WithHeader<Self>

where K: TryInto<HeaderName>, V: TryInto<HeaderValue>, Self: Sized,

Wrap an impl IntoResponse to add a header.

fn with_content_type<V>(self, content_type: V) -> WithContentType<Self>

where V: TryInto<HeaderValue>, Self: Sized,

Wrap an impl IntoResponse to with a new content type.

fn with_status(self, status: StatusCode) -> WithStatus<Self>

where Self: Sized,

Wrap an impl IntoResponse to set a status code.

fn with_body(self, body: impl Into<Body>) -> WithBody<Self>

where Self: Sized,

Wrap an impl IntoResponse to set a body.

impl<Ext: PartialEq> PartialEq for ProblemDetails<Ext>

fn eq(&self, other: &ProblemDetails<Ext>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Ext> ResponseError for ProblemDetails<Ext>

where Ext: Serialize + Clone + Send,

fn status(&self) -> StatusCode

The status code of this error.

fn as_response(&self) -> Response

Convert this error to a HTTP response.

impl<Ext> Serialize for ProblemDetails<Ext>

where Ext: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<Ext: Eq> Eq for ProblemDetails<Ext>

impl<Ext> StructuralEq for ProblemDetails<Ext>

impl<Ext> StructuralPartialEq for ProblemDetails<Ext>