mycelium-openapi 8.0.1-beta.5

Provide OpenAPI related elements to the mycelium project.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::{
    dtos::schema::Schema,
    entities::{DepthTracker, ReferenceResolver},
};

use mycelium_base::utils::errors::{execution_err, MappedErrors};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use utoipa::ToSchema;

#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct ValueSchema {
    schema: Schema,
}

impl ReferenceResolver for ValueSchema {
    fn resolve_ref(
        &self,
        components: &serde_json::Value,
        depth_tracker: &mut DepthTracker,
    ) -> Result<serde_json::Value, MappedErrors> {
        return self.schema.resolve_ref(components, depth_tracker);
    }
}

/// Content Schema
///
/// Should used to represent the content of the response.
///
/// Example:
///
/// ```json
/// {
///     "content": {
///         "application/json": {
///             "schema": {
///                 "type": "object"
///                 "properties": {
///                     "name": {
///                         "type": "string"
///                     }
///                 }
///             }
///         }
///     },
///     "description": "The response content",
///     "required": true
/// }
/// ```
///
/// or, using a reference to a schema:
///
/// ```json
/// {
///     "content": {
///         "application/json": {
///             "schema": {
///                 "$ref": "#/components/schemas/HttpJsonResponse"
///             }
///         }
///     },
///     "description": "The response content",
///     "required": true
/// }
/// ```
///
/// This struct refers to the value of the schema in response.
///
#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, ToSchema)]
#[serde(rename_all = "camelCase")]
pub struct Content {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    content: Option<HashMap<String, ValueSchema>>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    description: Option<String>,

    #[serde(default, skip_serializing_if = "Option::is_none")]
    required: Option<bool>,
}

impl ReferenceResolver for Content {
    fn resolve_ref(
        &self,
        components: &serde_json::Value,
        depth_tracker: &mut DepthTracker,
    ) -> Result<serde_json::Value, MappedErrors> {
        if depth_tracker.should_stop() {
            return Ok(depth_tracker.empty_value());
        }

        depth_tracker.increment();

        let mut value = serde_json::to_value(self).map_err(|e| {
            execution_err(format!("Failed to serialize content: {e}"))
        })?;

        if let Some(content) = self.content.as_ref() {
            let content = content
                .iter()
                .map(|(key, value)| {
                    (
                        key,
                        value.resolve_ref(components, depth_tracker).map_err(
                            |e| {
                                execution_err(format!(
                                    "Failed to resolve content: {e}"
                                ))
                            },
                        ),
                    )
                })
                .filter(|(_, value)| value.is_ok())
                .map(|(key, value)| (key.clone(), value.unwrap()))
                .collect::<HashMap<String, serde_json::Value>>();

            value["content"] = serde_json::to_value(content).map_err(|e| {
                execution_err(format!("Failed to serialize content: {e}"))
            })?;
        }

        Ok(value)
    }
}