Enum ProblemFormat 

pub enum ProblemFormat {
    ProblemJson,
    Json,
}

The media type a Problem response is served as: the RFC 9457 default application/problem+json, or plain application/json for clients that explicitly prefer it.

This is the opt-in content negotiation half of the problem feature. Problem’s plain IntoResponse impl always emits application/problem+json; nothing changes for existing users. To negotiate, either extract ProblemFormat in a handler (it implements FromRequestParts infallibly, reading the Accept headers) and finish with Problem::into_response_with, or call Problem::into_response_for with the request’s HeaderMap directly.

Both formats serve byte-identical JSON bodies; only the Content-Type header differs. Default is ProblemFormat::ProblemJson.

Example

use axum::{http::StatusCode, response::Response, routing::get, Router};
use axum_api_kit::{Problem, ProblemFormat};

// Accept: application/json          -> Content-Type: application/json
// Accept: */* (or no Accept header) -> Content-Type: application/problem+json
async fn not_found(format: ProblemFormat) -> Response {
    Problem::new(StatusCode::NOT_FOUND, "Not Found").into_response_with(format)
}

let app: Router = Router::new().route("/missing", get(not_found));

Variants

ProblemJson

Serve Content-Type: application/problem+json (the RFC 9457 media type, and the default in every ambiguous case).

Json

Serve Content-Type: application/json, for clients whose Accept header strictly prefers plain JSON.

Implementations

impl ProblemFormat

pub fn negotiate(headers: &HeaderMap) -> Self

Chooses the response format from a request’s Accept headers.

This is a minimal, hand-rolled matcher, deliberately not a full RFC 9110 implementation. The rules:

1. Recognized media ranges are application/problem+json, application/json, application/*, and */* (ASCII case-insensitive, across all Accept headers). Every other range, including other +json suffix types, is ignored.
2. A range’s weight is its q parameter (default 1). Parameters other than the first q are ignored. A range whose q value does not parse per the RFC 9110 qvalue grammar (0 to 1 with at most three decimals) is ignored entirely.
3. Each of the two servable types takes its weight from the most specific matching range (an exact match beats application/*, which beats */*); among equally specific matches the highest q wins.
4. ProblemFormat::Json is returned only when plain application/json ends up with a strictly higher weight than application/problem+json. Everything else (no Accept header, */*, application/*, equal weights, q=0 on both, unparseable headers) returns ProblemFormat::ProblemJson.

Accept	result
(absent)	problem+json
*/*	problem+json
application/*	problem+json
application/json	plain JSON
application/problem+json	problem+json
application/json, */*	problem+json (tie at q=1)
application/json;q=0.9, application/problem+json;q=0.5	plain JSON
application/problem+json, application/json	problem+json (tie)
text/html	problem+json (neither matched)

Example

use axum::http::{header, HeaderMap, HeaderValue};
use axum_api_kit::ProblemFormat;

let mut headers = HeaderMap::new();
headers.insert(header::ACCEPT, HeaderValue::from_static("application/json"));
assert_eq!(ProblemFormat::negotiate(&headers), ProblemFormat::Json);

assert_eq!(
    ProblemFormat::negotiate(&HeaderMap::new()),
    ProblemFormat::ProblemJson
);

pub fn content_type(self) -> &'static str

The Content-Type value this format serves.

Example

use axum_api_kit::{ProblemFormat, APPLICATION_PROBLEM_JSON};

assert_eq!(ProblemFormat::ProblemJson.content_type(), APPLICATION_PROBLEM_JSON);
assert_eq!(ProblemFormat::Json.content_type(), "application/json");

Trait Implementations

impl Clone for ProblemFormat

fn clone(&self) -> ProblemFormat

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ProblemFormat

impl Debug for ProblemFormat

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

Formats the value using the given formatter.

impl Default for ProblemFormat

fn default() -> ProblemFormat

Returns the “default value” for a type.

impl Eq for ProblemFormat

impl<S> FromRequestParts<S> for ProblemFormat

where S: Send + Sync,

type Rejection = Infallible

If the extractor fails it’ll use this “rejection” type. A rejection is a kind of error that can be converted into a response.

async fn from_request_parts( parts: &mut Parts, _state: &S, ) -> Result<Self, Self::Rejection>

Perform the extraction.

impl PartialEq for ProblemFormat

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ProblemFormat