avrotize 0.1.1

Convert JSON Schema to Avro with Rust
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

use super::merging::merge_avro_schemas;
use serde_json::Value;

/// Flatten a union type into a simplified list of unique types.
///
/// This will:
/// - Recursively expand nested lists (e.g. unions of unions),
/// - Remove duplicates,
/// - Merge multiple `array` or `map` definitions into one.
pub fn flatten_union(type_list: &[Value], avro_schemas: &[Value]) -> Vec<Value> {
    let mut flat_list: Vec<Value> = Vec::new();

    // Expand nested lists and remove duplicates
    for t in type_list {
        if t.is_array() {
            let inner = flatten_union(t.as_array().unwrap(), avro_schemas);
            for u in inner {
                if !flat_list.contains(&u) {
                    flat_list.push(u);
                }
            }
        } else if !flat_list.contains(t) {
            flat_list.push(t.clone());
        }
    }

    // Consolidate array/map definitions
    let mut array_type: Option<Value> = None;
    let mut map_type: Option<Value> = None;
    let mut flat_list_1: Vec<Value> = Vec::new();

    for t in flat_list {
        if let Some(obj) = t.as_object() {
            if obj.get("type") == Some(&Value::String("array".to_string()))
                && obj.contains_key("items")
            {
                if let Some(existing) = array_type.take() {
                    array_type = Some(merge_avro_schemas(
                        &[existing, t.clone()],
                        avro_schemas,
                        None,
                        &mut Vec::new(),
                    ));
                } else {
                    array_type = Some(t.clone());
                    flat_list_1.push(t.clone());
                }
            } else if obj.get("type") == Some(&Value::String("map".to_string()))
                && obj.contains_key("values")
            {
                if let Some(existing) = map_type.take() {
                    map_type = Some(merge_avro_schemas(
                        &[existing, t.clone()],
                        avro_schemas,
                        None,
                        &mut Vec::new(),
                    ));
                } else {
                    map_type = Some(t.clone());
                    flat_list_1.push(t.clone());
                }
            } else if !flat_list_1.contains(&t) {
                flat_list_1.push(t.clone());
            }
        } else if !flat_list_1.contains(&t) {
            flat_list_1.push(t.clone());
        }
    }

    flat_list_1
}