mockforge-proxy 0.3.235

Proxy functionality for forwarding requests to upstream services
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//! Resolve the declared status and media type before JSON schema validation.

use serde_json::Value;

pub(super) fn declared_json_schema(
    responses: &openapiv3::Responses,
    status: u16,
    spec: &openapiv3::OpenAPI,
    content_type: Option<&str>,
) -> Result<Option<Value>, String> {
    use openapiv3::{ReferenceOr, Response, StatusCode};
    // Exact status overrides a range, which overrides the default response.
    let response_ref: Option<&ReferenceOr<Response>> = responses
        .responses
        .get(&StatusCode::Code(status))
        .or_else(|| responses.responses.get(&StatusCode::Range(status / 100)))
        .or(responses.default.as_ref());
    let mut selected = response_ref.ok_or("response contract is missing")?.clone();
    let mut resolved = None;
    // Resolve only local response references, bounded against cycles.
    for _ in 0..32 {
        match selected {
            ReferenceOr::Item(response) => {
                resolved = Some(response);
                break;
            }
            ReferenceOr::Reference { reference } => {
                let name = reference
                    .strip_prefix("#/components/responses/")
                    .ok_or("external response references are unsupported")?
                    .replace("~1", "/")
                    .replace("~0", "~");
                selected = spec
                    .components
                    .as_ref()
                    .and_then(|c| c.responses.get(&name))
                    .ok_or("response reference cannot be resolved")?
                    .clone();
            }
        }
    }
    let response = resolved.ok_or("response reference cycle exceeds the resolution limit")?;
    if response.content.is_empty() {
        return Ok(None);
    }
    let actual = content_type
        .and_then(|v| v.split(';').next())
        .map(|v| v.trim().to_ascii_lowercase())
        .ok_or("response content-type is missing")?;
    let media = response
        .content
        .iter()
        .find(|(name, _)| name.eq_ignore_ascii_case(&actual))
        .or_else(|| {
            actual
                .split_once('/')
                .and_then(|(kind, _)| response.content.get_key_value(&format!("{kind}/*")))
        })
        .or_else(|| response.content.get_key_value("*/*"))
        .map(|(_, media)| media)
        .ok_or_else(|| format!("response content-type {actual} is not declared"))?;
    // Other declared representations pass through; this validator checks JSON schemas.
    if actual != "application/json" && !actual.ends_with("+json") {
        return Ok(None);
    }
    match &media.schema {
        Some(ReferenceOr::Item(schema)) => {
            serde_json::to_value(schema).map(Some).map_err(|e| e.to_string())
        }
        Some(ReferenceOr::Reference { reference }) => {
            Ok(Some(serde_json::json!({ "$ref": reference })))
        }
        None => Ok(None),
    }
}