Skip to main content

arri_repr/
elements.rs

1use crate::{MetadataSchema, Serializable, serializer::Serializer};
2
3/// Represents the schema for elements in arri
4///
5/// This struct defines the structure of elements, including their serializable
6/// representation, optional metadata, and nullability.
7///
8/// # Fields
9///
10/// * `elements` - A boxed trait object implementing the `Serializable` trait,
11///   representing the serializable content of the elements.
12/// * `metadata` - An optional `MetadataSchema` providing additional information
13///   about the elements.
14/// * `is_nullable` - An optional boolean indicating whether the elements can
15///   be null.
16#[derive(Debug, Eq)]
17pub struct ElementsSchema {
18    pub elements: Box<dyn Serializable>,
19    pub metadata: Option<MetadataSchema>,
20    pub is_nullable: Option<bool>,
21}
22
23impl ElementsSchema {
24    pub fn new(elements: Box<dyn Serializable>) -> Self {
25        Self {
26            elements,
27            metadata: None,
28            is_nullable: None,
29        }
30    }
31}
32
33impl PartialEq for ElementsSchema {
34    fn eq(&self, other: &Self) -> bool {
35        self.elements.eq(&other.elements)
36    }
37}
38
39impl Serializable for ElementsSchema {
40    fn serialize(&self) -> Option<String> {
41        Serializer::builder()
42            .set("elements", &self.elements)
43            .set("metadata", &self.metadata)
44            .set("isNullable", &self.is_nullable)
45            .build()
46            .into()
47    }
48
49    fn set_metadata(&mut self, metadata: MetadataSchema) {
50        self.metadata = Some(metadata);
51    }
52
53    fn set_nullable(&mut self, nullable: bool) {
54        self.is_nullable = Some(nullable);
55    }
56}
57
58#[cfg(test)]
59mod tests {
60    use crate::{TypeSchema, Types};
61
62    use super::*;
63
64    #[test]
65    fn test_vec_serialize() {
66        let type_schema = ElementsSchema::new(Box::new(TypeSchema::new(Types::String)));
67        let serialized: serde_json::Value =
68            serde_json::from_str(&type_schema.serialize().unwrap()).unwrap();
69
70        assert_eq!(
71            serialized,
72            serde_json::json!({ "elements": { "type": "string" } })
73        );
74    }
75
76    #[test]
77    fn test_vec_metadata() {
78        let mut type_schema = ElementsSchema::new(Box::new(TypeSchema::new(Types::String)));
79        type_schema.set_metadata(MetadataSchema::new().set_id("test").to_owned());
80
81        assert_eq!(
82            type_schema.metadata,
83            Some(MetadataSchema::new().set_id("test").to_owned())
84        );
85    }
86
87    #[test]
88    fn test_vec_nullable() {
89        let mut type_schema = ElementsSchema::new(Box::new(TypeSchema::new(Types::String)));
90        type_schema.set_nullable(true);
91
92        assert_eq!(type_schema.is_nullable, Some(true));
93    }
94}