mycelium-openapi 8.2.1

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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::{
    dtos::{items_type::ItemsType, schema_type::SchemaType},
    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 Schema {
    #[serde(rename = "$ref", skip_serializing_if = "Option::is_none")]
    pub reference: Option<String>,

    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SchemaType>,

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

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

    #[serde(skip_serializing_if = "Option::is_none")]
    pub nullable: Option<bool>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub required: Option<Vec<String>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    #[schema(no_recursion)]
    pub properties: Option<HashMap<String, Schema>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub items: Option<Box<ItemsType>>,

    #[serde(skip_serializing_if = "Option::is_none")]
    pub enum_values: Option<Vec<serde_json::Value>>,

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

    #[serde(skip_serializing_if = "Option::is_none")]
    pub default: Option<serde_json::Value>,
}

impl ReferenceResolver for Schema {
    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 schema: {e}"))
        })?;

        if let Some(reference) = &self.reference {
            //
            // Example:
            //
            // "#/components/schemas/APIAccountType"
            //
            let ref_path = reference.split('/').collect::<Vec<&str>>();

            //
            // Here the element is defined. Possible values are:
            //
            // - schemas
            // - responses
            // - parameters
            // - examples
            // - requestBodies
            // - headers
            // - securitySchemes
            //
            // Element is the penultimate element of the ref_path
            //
            // Example:
            //
            // The path: "#/components/schemas/APIAccountType"
            // The element is: "schemas"
            //
            let element_definition = if ref_path.len() > 2 {
                ref_path[ref_path.len() - 2]
            } else {
                return Ok(depth_tracker.empty_value());
            };

            //
            // The element name is the last element of the ref_path
            //
            // Example:
            //
            // The path: "#/components/schemas/APIAccountType"
            // The element name is: "APIAccountType"
            //
            let element_name = ref_path.last().ok_or(execution_err(format!(
                "Failed to resolve schema ref. Unable to get the component name from reference: {reference}"
            )))?;

            // Find in nested components
            //
            // Components should be a map with keys:
            //
            // We need to traverse the ref_path to find the value.
            //
            let ref_value = components
                .get(element_definition)
                .and_then(|schema| schema.get(element_name))
                .ok_or(
                    execution_err(format!(
                        "Failed to resolve schema ref: {element_name}"
                    ))
                    .with_exp_true(),
                )?;

            return Ok(ref_value.clone());
        }

        //
        // Resolve properties and items
        //
        if let Some(properties) = &self.properties {
            for (key, schema) in properties {
                let resolved_value =
                    schema.resolve_ref(components, depth_tracker)?;

                value["properties"][key] = resolved_value;
            }
        }

        //
        // Resolve items
        //
        if let Some(items) = &self.items {
            let resolved_value =
                items.resolve_ref(components, depth_tracker)?;

            value["items"] = resolved_value;
        }

        Ok(value)
    }
}