openapiv3_resolve/resolved/
response.rs1use 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#[derive(Debug, PartialEq)]
9pub struct ResolvedRequestBody {
10 pub description: Option<String>,
12 pub content: IndexMap<String, ResolvedMediaType>,
14 pub required: bool,
16 pub extensions: IndexMap<String, serde_json::Value>,
18}
19
20#[derive(Debug, PartialEq)]
22pub struct ResolvedResponse {
23 pub description: String,
25 pub headers: IndexMap<String, Shared<ResolvedHeader>>,
27 pub content: IndexMap<String, ResolvedMediaType>,
29 pub links: IndexMap<String, Shared<Link>>,
31 pub extensions: IndexMap<String, serde_json::Value>,
33}
34
35#[derive(Debug, PartialEq)]
37pub struct ResolvedMediaType {
38 pub schema: Option<Shared<ResolvedSchema>>,
40 pub example: Option<serde_json::Value>,
42 pub examples: IndexMap<String, Shared<Example>>,
44 pub encoding: IndexMap<String, ResolvedEncoding>,
46 pub extensions: IndexMap<String, serde_json::Value>,
48}
49
50#[derive(Debug, PartialEq)]
52pub struct ResolvedEncoding {
53 pub content_type: Option<String>,
55 pub headers: IndexMap<String, Shared<ResolvedHeader>>,
57 pub style: Option<QueryStyle>,
59 pub explode: bool,
61 pub allow_reserved: bool,
63 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}