Struct ProblemJson 

pub struct ProblemJson {
    pub type: String,
    pub title: String,
    pub status: u16,
    pub detail: String,
    pub instance: Option<String>,
    pub extensions: BTreeMap<String, Value>,
}

RFC 7807 / 9457 Problem Details response body with optional extension members.

Unlike ApiError (which carries in-process state such as source and Arc), ProblemJson is a pure serialization type — every field maps directly to the wire format.

The extensions map serializes flat into the JSON object, so arbitrary key-value members (e.g. trace_id, request_id) appear at the top level alongside the standard fields:

{
  "type":     "urn:api-bones:error:resource-not-found",
  "title":    "Resource Not Found",
  "status":   404,
  "detail":   "Booking 42 not found",
  "instance": "urn:uuid:01234567-89ab-cdef-0123-456789abcdef",
  "trace_id": "abc123"
}

Content-Type is application/problem+json.

no_std support

Available when either std or alloc is enabled together with serde (required for serde_json::Value and BTreeMap). Uses BTreeMap internally so heap allocation is the only requirement — std is not needed.

Examples

use api_bones::error::{ApiError, ErrorCode, ProblemJson};

let err = ApiError::not_found("booking 42 not found");
let problem = ProblemJson::from(err);
assert_eq!(problem.status, 404);
assert_eq!(problem.title, "Resource Not Found");

Adding extension members:

use api_bones::error::{ApiError, ProblemJson};

let mut problem = ProblemJson::from(ApiError::internal("db timeout"));
problem.extensions.insert("trace_id".into(), "abc123".into());
assert_eq!(problem.extensions["trace_id"], "abc123");

Fields

type: String

Machine-readable error type URI (RFC 9457 §3.1.1 type).

title: String

Human-friendly summary (RFC 9457 §3.1.2 title).

status: u16

HTTP status code (RFC 9457 §3.1.3 status).

detail: String

Human-readable specifics (RFC 9457 §3.1.4 detail).

instance: Option<String>

URI identifying this occurrence (RFC 9457 §3.1.5 instance).

extensions: BTreeMap<String, Value>

Flat extension members (e.g. trace_id, request_id).

Serialized inline at the top level of the JSON object via #[serde(flatten)]. Keys must not collide with the standard fields. Uses BTreeMap for no_std compatibility.

Implementations

impl ProblemJson

pub fn new( type: impl Into<String>, title: impl Into<String>, status: u16, detail: impl Into<String>, ) -> Self

Build a ProblemJson directly from its components.

Examples

use api_bones::error::ProblemJson;

let p = ProblemJson::new(
    "urn:api-bones:error:bad-request",
    "Bad Request",
    400,
    "missing field `email`",
);
assert_eq!(p.status, 400);
assert!(p.extensions.is_empty());

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

Set the instance field (RFC 9457 §3.1.5).

Examples

use api_bones::error::ProblemJson;

let p = ProblemJson::new("urn:api-bones:error:bad-request", "Bad Request", 400, "oops")
    .with_instance("urn:uuid:00000000-0000-0000-0000-000000000000");
assert!(p.instance.is_some());

pub fn extend(&mut self, key: impl Into<String>, value: impl Into<Value>)

Insert an extension member.

Examples

use api_bones::error::ProblemJson;

let mut p = ProblemJson::new("urn:api-bones:error:bad-request", "Bad Request", 400, "oops");
p.extend("trace_id", "abc123");
assert_eq!(p.extensions["trace_id"], "abc123");

Trait Implementations

impl Clone for ProblemJson

fn clone(&self) -> ProblemJson

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ProblemJson

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ProblemJson

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ApiError> for ProblemJson

Available on crate features std and serde only.

fn from(err: ApiError) -> Self

Convert an ApiError into a ProblemJson.

• code → type via ErrorCode::urn
• request_id (UUID) → instance as "urn:uuid:<id>"
• errors (validation) → "errors" extension member
• source is dropped (not part of the wire format)

Examples

use api_bones::error::{ApiError, ErrorCode, ProblemJson};

let err = ApiError::new(ErrorCode::Forbidden, "not allowed");
let p = ProblemJson::from(err);
assert_eq!(p.status, 403);
assert_eq!(p.title, "Forbidden");

impl PartialEq for ProblemJson

fn eq(&self, other: &ProblemJson) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for ProblemJson

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ProblemJson