interstice_abi/schema/
module.rs

1use crate::{
2    ABI_VERSION, Authority, IntersticeType, ModuleDependency, NodeDependency, QuerySchema,
3    ReducerSchema, SubscriptionSchema, TableSchema, TableVisibility, Version,
4    interstice_type_def::IntersticeTypeDef,
5};
6use serde::{Deserialize, Serialize};
7use std::collections::HashMap;
8
9#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
10pub enum ModuleVisibility {
11    // Visible to all other nodes
12    Public,
13    // Only visible for local modules on the current node
14    Private,
15}
16
17#[derive(Debug, Clone, Deserialize, Serialize)]
18pub struct ModuleSchema {
19    pub abi_version: u16,
20    pub name: String,
21    pub version: Version,
22    pub visibility: ModuleVisibility,
23    pub reducers: Vec<ReducerSchema>,
24    pub queries: Vec<QuerySchema>,
25    pub tables: Vec<TableSchema>,
26    pub subscriptions: Vec<SubscriptionSchema>,
27    pub type_definitions: HashMap<String, IntersticeTypeDef>,
28    pub authorities: Vec<Authority>,
29    pub module_dependencies: Vec<ModuleDependency>,
30    pub node_dependencies: Vec<NodeDependency>,
31}
32
33impl ModuleSchema {
34    pub fn empty() -> Self {
35        Self {
36            abi_version: 0,
37            name: "".into(),
38            version: Version {
39                major: 0,
40                minor: 0,
41                patch: 0,
42            },
43            visibility: ModuleVisibility::Private,
44            reducers: Vec::new(),
45            queries: Vec::new(),
46            tables: Vec::new(),
47            subscriptions: Vec::new(),
48            type_definitions: HashMap::new(),
49            authorities: Vec::new(),
50            module_dependencies: Vec::new(),
51            node_dependencies: Vec::new(),
52        }
53    }
54
55    pub fn new(
56        name: impl Into<String>,
57        version: Version,
58        visibility: ModuleVisibility,
59        reducers: Vec<ReducerSchema>,
60        queries: Vec<QuerySchema>,
61        tables: Vec<TableSchema>,
62        subscriptions: Vec<SubscriptionSchema>,
63        type_definitions: HashMap<String, IntersticeTypeDef>,
64        authorities: Vec<Authority>,
65        module_dependencies: Vec<ModuleDependency>,
66        node_dependencies: Vec<NodeDependency>,
67    ) -> Self {
68        Self {
69            abi_version: ABI_VERSION,
70            name: name.into(),
71            visibility,
72            version,
73            reducers,
74            queries,
75            tables,
76            subscriptions,
77            type_definitions,
78            authorities,
79            module_dependencies,
80            node_dependencies,
81        }
82    }
83
84    pub fn to_public(self) -> Self {
85        let mut type_definitions = HashMap::new();
86        let mut tables = Vec::new();
87        for table_schema in &self.tables {
88            if table_schema.visibility == TableVisibility::Public {
89                tables.push(table_schema.clone());
90                for field in &table_schema.fields {
91                    if let IntersticeType::Named(type_name) = field.field_type.clone() {
92                        if !type_definitions.contains_key(&type_name) {
93                            let type_def = self.type_definitions.get(&type_name).unwrap().clone();
94                            type_definitions.insert(type_name, type_def);
95                        }
96                    }
97                }
98                type_definitions.insert(
99                    table_schema.type_name.clone(),
100                    self.type_definitions
101                        .get(&table_schema.type_name)
102                        .unwrap()
103                        .clone(),
104                );
105            }
106        }
107        let mut reducers = Vec::new();
108        for reducer_schema in &self.reducers {
109            let mut add_reducer = true;
110            for subscription in &self.subscriptions {
111                if subscription.reducer_name == reducer_schema.name {
112                    add_reducer = false;
113                    break;
114                }
115            }
116            if add_reducer {
117                reducers.push(reducer_schema.clone());
118            }
119        }
120
121        let queries = self.queries.clone();
122
123        Self {
124            abi_version: self.abi_version,
125            name: self.name,
126            visibility: self.visibility,
127            version: self.version,
128            reducers,
129            queries,
130            tables,
131            subscriptions: Vec::new(),
132            type_definitions,
133            authorities: self.authorities,
134            module_dependencies: self.module_dependencies,
135            node_dependencies: self.node_dependencies,
136        }
137    }
138
139    pub fn from_toml_string(toml_string: &str) -> Result<Self, toml::de::Error> {
140        toml::from_str(toml_string)
141    }
142
143    pub fn to_toml_string(&self) -> Result<String, toml::ser::Error> {
144        toml::to_string(&self)
145    }
146}
interstice_abi/schema/module.rs

interstice_abi/schema/
module.rs
