vdev 0.3.8

CLI utilities for Vector (vector.dev) development and CI workflows
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

use super::{SchemaContext, get_schema_ref, nested_merge};
use anyhow::{Result, anyhow};
use serde_json::Value;

impl SchemaContext {
    pub fn get_json_schema_instance_type<'a>(&self, schema: &'a Value) -> Option<&'a str> {
        let maybe_type = schema.get("type")?;

        if maybe_type.is_null() || maybe_type.as_str() == Some("null") {
            return None;
        }

        if let Value::Array(arr) = maybe_type {
            let filtered: Vec<_> = arr.iter().filter(|v| v.as_str() != Some("null")).collect();
            if filtered.len() == 1 {
                return filtered[0].as_str();
            }
        } else if let Some(s) = maybe_type.as_str() {
            return Some(s);
        }

        None
    }

    pub fn get_json_schema_type<'a>(&self, schema: &'a Value) -> Option<&'a str> {
        if schema.get("allOf").is_some() {
            Some("all-of")
        } else if schema.get("oneOf").is_some() {
            Some("one-of")
        } else if schema.get("anyOf").is_some() {
            Some("any-of")
        } else if schema.get("type").is_some() {
            self.get_json_schema_instance_type(schema)
        } else if schema.get("const").is_some() {
            Some("const")
        } else if schema.get("enum").is_some() {
            Some("enum")
        } else {
            None
        }
    }

    pub fn get_schema_by_name(&self, schema_name: &str) -> Result<Value> {
        let name = schema_name.replace("#/definitions/", "");
        let def = self
            .root_schema
            .get("definitions")
            .and_then(|defs| defs.get(&name))
            .cloned();

        if let Some(d) = def {
            Ok(d)
        } else {
            Err(anyhow!(
                "Could not find schema definition '{name}' in given schema."
            ))
        }
    }

    pub fn expand_schema_references(&mut self, unexpanded_schema: &Value) -> Result<Value> {
        let mut schema = unexpanded_schema.clone();

        let original_title = schema.get("title").cloned();
        let original_description = schema.get("description").cloned();

        let schema_ref = get_schema_ref(&schema).map(String::from);
        if let Some(r) = schema_ref {
            let expanded_ref = if let Some(cached) = self.expanded_schema_cache.get(&r) {
                cached.clone()
            } else {
                debug!("Expanding top-level schema ref of '{}'...", r);
                let unexpanded = self.get_schema_by_name(&r)?;
                let expanded = self.expand_schema_references(&unexpanded)?;
                self.expanded_schema_cache
                    .insert(r.clone(), expanded.clone());
                expanded
            };

            let obj = schema.as_object_mut().unwrap();
            obj.shift_remove("$ref");

            let mut new_schema = expanded_ref.clone();
            nested_merge(&mut new_schema, &Value::Object(obj.clone()));
            schema = new_schema;
        }

        if let Some(items) = schema.get("items").cloned()
            && items.get("$ref").is_some()
        {
            let expanded_items = self.expand_schema_references(&items)?;
            let items_mut = schema.get_mut("items").unwrap().as_object_mut().unwrap();
            items_mut.shift_remove("$ref");

            let mut new_items = expanded_items;
            nested_merge(&mut new_items, &Value::Object(items_mut.clone()));
            *schema.get_mut("items").unwrap() = new_items;
        }

        if let Some(Value::Object(properties)) = schema.get_mut("properties") {
            for (_, prop_schema) in properties.iter_mut() {
                *prop_schema = self.expand_schema_references(&prop_schema.clone())?;
            }
        }

        for key in &["allOf", "oneOf", "anyOf"] {
            if let Some(Value::Array(arr)) = schema.get_mut(*key) {
                let mut new_arr = Vec::new();
                for subschema in arr.iter() {
                    new_arr.push(self.expand_schema_references(subschema)?);
                }
                *arr = new_arr;
            }
        }

        if original_title.is_some() || original_description.is_some() {
            let obj = schema.as_object_mut().unwrap();
            if let Some(t) = original_title {
                obj.insert("title".to_string(), t);
            } else {
                obj.shift_remove("title");
            }
            if let Some(d) = original_description {
                obj.insert("description".to_string(), d);
            } else {
                obj.shift_remove("description");
            }
        }

        Ok(schema)
    }
}