Skip to main content

openapiv3_resolve/resolved/
response.rs

1use super::resolver::{Resolvable, Resolver};
2use super::{ResolvedHeader, ResolvedSchema, Shared};
3use crate::ResolveError;
4use indexmap::IndexMap;
5use openapiv3::{Encoding, Example, Link, MediaType, QueryStyle, RequestBody, Response};
6
7/// [`RequestBody`] with every `$ref` replaced by the item it named.
8#[derive(Debug, PartialEq)]
9pub struct ResolvedRequestBody {
10    /// See [`RequestBody::description`].
11    pub description: Option<String>,
12    /// See [`RequestBody::content`].
13    pub content: IndexMap<String, ResolvedMediaType>,
14    /// See [`RequestBody::required`].
15    pub required: bool,
16    /// See [`RequestBody::extensions`].
17    pub extensions: IndexMap<String, serde_json::Value>,
18}
19
20/// [`Response`] with every `$ref` replaced by the item it named.
21#[derive(Debug, PartialEq)]
22pub struct ResolvedResponse {
23    /// See [`Response::description`].
24    pub description: String,
25    /// See [`Response::headers`].
26    pub headers: IndexMap<String, Shared<ResolvedHeader>>,
27    /// See [`Response::content`].
28    pub content: IndexMap<String, ResolvedMediaType>,
29    /// See [`Response::links`].
30    pub links: IndexMap<String, Shared<Link>>,
31    /// See [`Response::extensions`].
32    pub extensions: IndexMap<String, serde_json::Value>,
33}
34
35/// [`MediaType`] with every `$ref` replaced by the item it named.
36#[derive(Debug, PartialEq)]
37pub struct ResolvedMediaType {
38    /// See [`MediaType::schema`].
39    pub schema: Option<Shared<ResolvedSchema>>,
40    /// See [`MediaType::example`].
41    pub example: Option<serde_json::Value>,
42    /// See [`MediaType::examples`].
43    pub examples: IndexMap<String, Shared<Example>>,
44    /// See [`MediaType::encoding`].
45    pub encoding: IndexMap<String, ResolvedEncoding>,
46    /// See [`MediaType::extensions`].
47    pub extensions: IndexMap<String, serde_json::Value>,
48}
49
50/// [`Encoding`] with every `$ref` replaced by the item it named.
51#[derive(Debug, PartialEq)]
52pub struct ResolvedEncoding {
53    /// See [`Encoding::content_type`].
54    pub content_type: Option<String>,
55    /// See [`Encoding::headers`].
56    pub headers: IndexMap<String, Shared<ResolvedHeader>>,
57    /// See [`Encoding::style`].
58    pub style: Option<QueryStyle>,
59    /// See [`Encoding::explode`].
60    pub explode: bool,
61    /// See [`Encoding::allow_reserved`].
62    pub allow_reserved: bool,
63    /// See [`Encoding::extensions`].
64    pub extensions: IndexMap<String, serde_json::Value>,
65}
66
67impl Resolvable for RequestBody {
68    type Resolved = ResolvedRequestBody;
69
70    fn resolve_inline(&self, cx: &mut Resolver<'_>) -> Result<Self::Resolved, ResolveError> {
71        Ok(ResolvedRequestBody {
72            description: self.description.clone(),
73            content: super::resolve_map(&self.content, cx)?,
74            required: self.required,
75            extensions: self.extensions.clone(),
76        })
77    }
78}
79
80impl Resolvable for Response {
81    type Resolved = ResolvedResponse;
82
83    fn resolve_inline(&self, cx: &mut Resolver<'_>) -> Result<Self::Resolved, ResolveError> {
84        Ok(ResolvedResponse {
85            description: self.description.clone(),
86            headers: cx.ref_or_map(&self.headers)?,
87            content: super::resolve_map(&self.content, cx)?,
88            links: cx.ref_or_map(&self.links)?,
89            extensions: self.extensions.clone(),
90        })
91    }
92}
93
94impl Resolvable for MediaType {
95    type Resolved = ResolvedMediaType;
96
97    fn resolve_inline(&self, cx: &mut Resolver<'_>) -> Result<Self::Resolved, ResolveError> {
98        Ok(ResolvedMediaType {
99            schema: self
100                .schema
101                .as_ref()
102                .map(|schema| cx.ref_or(schema))
103                .transpose()?,
104            example: self.example.clone(),
105            examples: cx.ref_or_map(&self.examples)?,
106            encoding: super::resolve_map(&self.encoding, cx)?,
107            extensions: self.extensions.clone(),
108        })
109    }
110}
111
112impl Resolvable for Encoding {
113    type Resolved = ResolvedEncoding;
114
115    fn resolve_inline(&self, cx: &mut Resolver<'_>) -> Result<Self::Resolved, ResolveError> {
116        Ok(ResolvedEncoding {
117            content_type: self.content_type.clone(),
118            headers: cx.ref_or_map(&self.headers)?,
119            style: self.style.clone(),
120            explode: self.explode,
121            allow_reserved: self.allow_reserved,
122            extensions: self.extensions.clone(),
123        })
124    }
125}