gwp 0.2.1

A standalone, pure Rust gRPC wire protocol for GQL (ISO/IEC 39075)
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
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
132
133
134
135

//! Property graph node type.

use std::collections::HashMap;

use super::Value;
use crate::proto;

/// A property graph node with an opaque ID, labels, and properties.
///
/// ```
/// use gwp::types::{Node, Value};
///
/// let node = Node::new(1_i64.to_be_bytes())
///     .with_label("Person")
///     .with_property("name", "Alice")
///     .with_property("age", 30_i64);
///
/// assert!(node.has_label("Person"));
/// assert_eq!(node.property("name"), Some(&Value::String("Alice".into())));
/// assert_eq!(node.property("age"), Some(&Value::Integer(30)));
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct Node {
    /// Opaque element identifier.
    pub id: Vec<u8>,
    /// Label set (unordered).
    pub labels: Vec<String>,
    /// Property map.
    pub properties: HashMap<String, Value>,
}

impl Node {
    /// Create a new node with the given ID.
    #[must_use]
    pub fn new(id: impl Into<Vec<u8>>) -> Self {
        Self {
            id: id.into(),
            labels: Vec::new(),
            properties: HashMap::new(),
        }
    }

    /// Add a label to the node.
    #[must_use]
    pub fn with_label(mut self, label: impl Into<String>) -> Self {
        self.labels.push(label.into());
        self
    }

    /// Add a property to the node.
    #[must_use]
    pub fn with_property(mut self, name: impl Into<String>, value: impl Into<Value>) -> Self {
        self.properties.insert(name.into(), value.into());
        self
    }

    /// Get a property value by name.
    #[must_use]
    pub fn property(&self, name: &str) -> Option<&Value> {
        self.properties.get(name)
    }

    /// Check if the node has a specific label.
    #[must_use]
    pub fn has_label(&self, label: &str) -> bool {
        self.labels.iter().any(|l| l == label)
    }
}

// ============================================================================
// Proto conversions
// ============================================================================

impl From<proto::Node> for Node {
    fn from(p: proto::Node) -> Self {
        Self {
            id: p.id,
            labels: p.labels,
            properties: p
                .properties
                .into_iter()
                .map(|(k, v)| (k, Value::from(v)))
                .collect(),
        }
    }
}

impl From<Node> for proto::Node {
    fn from(n: Node) -> Self {
        Self {
            id: n.id,
            labels: n.labels,
            properties: n
                .properties
                .into_iter()
                .map(|(k, v)| (k, proto::Value::from(v)))
                .collect(),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn builder_pattern() {
        let node = Node::new(1_i64.to_be_bytes())
            .with_label("Person")
            .with_label("Employee")
            .with_property("name", "Alice")
            .with_property("age", 30_i64);

        assert!(node.has_label("Person"));
        assert!(node.has_label("Employee"));
        assert!(!node.has_label("Company"));
        assert_eq!(
            node.property("name"),
            Some(&Value::String("Alice".to_owned()))
        );
        assert_eq!(node.property("age"), Some(&Value::Integer(30)));
        assert_eq!(node.property("missing"), None);
    }

    #[test]
    fn round_trip() {
        let node = Node::new(vec![0x01, 0x02])
            .with_label("Person")
            .with_property("name", "Bob");

        let proto_node: proto::Node = node.clone().into();
        let back: Node = proto_node.into();
        assert_eq!(node, back);
    }
}