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::dynamic;
use crate::Register;
use std::collections::{HashMap, VecDeque};
use std::mem;

pub struct Registry {
    root: Option<String>,
    mutation: Option<String>,
    objects: HashMap<String, dynamic::Object>,
    types: Vec<dynamic::Type>,
    pending_expand_objects: VecDeque<PendingExpandObject>,
}

impl Default for Registry {
    fn default() -> Self {
        Self::new()
    }
}

impl Registry {
    pub fn new() -> Self {
        Self {
            root: None,
            mutation: None,
            objects: Default::default(),
            types: Default::default(),
            pending_expand_objects: Default::default(),
        }
    }
}

struct PendingExpandObject {
    target: String,
    expansion: String,
    map_fn: Box<dyn FnOnce(dynamic::Object) -> dynamic::Object>,
}

impl Registry {
    #[inline]
    pub fn set_root(mut self, name: &str) -> Self {
        self.root = Some(name.to_string());
        self
    }
    #[inline]
    pub fn set_mutation(mut self, name: &str) -> Self {
        self.mutation = Some(name.to_string());
        self
    }
    pub fn register_type(mut self, ty: impl Into<dynamic::Type>) -> Self {
        let ty = ty.into();
        match ty {
            dynamic::Type::Object(object) => {
                self.objects.insert(object.type_name().to_string(), object);
            }
            _ => {
                self.types.push(ty);
            }
        }
        self
    }
    pub fn update_object<F>(mut self, target: &str, expansion_name: &str, f: F) -> Self
    where
        F: FnOnce(dynamic::Object) -> dynamic::Object + 'static,
    {
        self.pending_expand_objects.push_back(PendingExpandObject {
            target: target.to_string(),
            expansion: expansion_name.to_string(),
            map_fn: Box::new(f),
        });
        self
    }
}

impl Registry {
    #[inline]
    pub fn register<T: Register>(self) -> Self {
        T::register(self)
    }

    fn apply_pending_objects(&mut self) {
        loop {
            if self.pending_expand_objects.is_empty() {
                break;
            }
            let mut changed = false;
            let pending_expand_objects = mem::take(&mut self.pending_expand_objects);
            self.pending_expand_objects = pending_expand_objects
                .into_iter()
                .filter_map(|pending| {
                    if let Some(object) = self.objects.remove(&pending.target) {
                        self.objects
                            .insert(pending.target, (pending.map_fn)(object));
                        changed = true;
                        None
                    } else {
                        Some(pending)
                    }
                })
                .collect();
            if !changed {
                let keys = self
                    .pending_expand_objects
                    .iter()
                    .map(|p| format!("{} when defining {}", p.target, p.expansion))
                    .collect::<Vec<_>>()
                    .join(", ");
                panic!("Can't find object: {:?}", keys);
            }
        }
    }
    pub fn create_schema(mut self) -> dynamic::SchemaBuilder {
        self.apply_pending_objects();
        let Some(ref root) = self.root else {
            panic!("No root object defined");
        };
        let schema = dynamic::Schema::build(root, self.mutation.as_deref(), None);
        let schema = self
            .objects
            .into_iter()
            .fold(schema, |schema, (_, object)| schema.register(object));
        self.types
            .into_iter()
            .fold(schema, |schema, object| schema.register(object))
    }
}