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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Property graph edge type (directed or undirected).

use std::collections::HashMap;

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

/// A property graph edge with an opaque ID, labels, endpoints, and properties.
///
/// ```
/// use gwp::types::{Edge, Value};
///
/// let edge = Edge::directed(vec![0x10], vec![0x01], vec![0x02])
///     .with_label("KNOWS")
///     .with_property("since", 2020_i64);
///
/// assert!(!edge.undirected);
/// assert_eq!(edge.property("since"), Some(&Value::Integer(2020)));
///
/// let friend = Edge::undirected(vec![0x20], vec![0x01], vec![0x02])
///     .with_label("FRIENDS_WITH");
/// assert!(friend.undirected);
/// ```
#[derive(Debug, Clone, PartialEq)]
pub struct Edge {
    /// Opaque element identifier.
    pub id: Vec<u8>,
    /// Label set.
    pub labels: Vec<String>,
    /// Source node ID (directed) or endpoint A (undirected).
    pub source_node_id: Vec<u8>,
    /// Target node ID (directed) or endpoint B (undirected).
    pub target_node_id: Vec<u8>,
    /// Whether this is an undirected edge.
    pub undirected: bool,
    /// Property map.
    pub properties: HashMap<String, Value>,
}

impl Edge {
    /// Create a new directed edge.
    #[must_use]
    pub fn directed(
        id: impl Into<Vec<u8>>,
        source: impl Into<Vec<u8>>,
        target: impl Into<Vec<u8>>,
    ) -> Self {
        Self {
            id: id.into(),
            labels: Vec::new(),
            source_node_id: source.into(),
            target_node_id: target.into(),
            undirected: false,
            properties: HashMap::new(),
        }
    }

    /// Create a new undirected edge.
    #[must_use]
    pub fn undirected(
        id: impl Into<Vec<u8>>,
        endpoint_a: impl Into<Vec<u8>>,
        endpoint_b: impl Into<Vec<u8>>,
    ) -> Self {
        Self {
            id: id.into(),
            labels: Vec::new(),
            source_node_id: endpoint_a.into(),
            target_node_id: endpoint_b.into(),
            undirected: true,
            properties: HashMap::new(),
        }
    }

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

    /// Add a property to the edge.
    #[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)
    }
}

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

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

impl From<Edge> for proto::Edge {
    fn from(e: Edge) -> Self {
        Self {
            id: e.id,
            labels: e.labels,
            source_node_id: e.source_node_id,
            target_node_id: e.target_node_id,
            undirected: e.undirected,
            properties: e
                .properties
                .into_iter()
                .map(|(k, v)| (k, proto::Value::from(v)))
                .collect(),
        }
    }
}

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

    #[test]
    fn directed_edge() {
        let edge = Edge::directed(vec![0x10], vec![0x01], vec![0x02])
            .with_label("knows")
            .with_property("since", 2020_i64);

        assert!(!edge.undirected);
        assert_eq!(edge.labels, vec!["knows"]);
        assert_eq!(edge.property("since"), Some(&Value::Integer(2020)));
    }

    #[test]
    fn undirected_edge() {
        let edge = Edge::undirected(vec![0x10], vec![0x01], vec![0x02]).with_label("friends_with");

        assert!(edge.undirected);
    }

    #[test]
    fn round_trip() {
        let edge = Edge::directed(vec![0x10], vec![0x01], vec![0x02])
            .with_label("knows")
            .with_property("weight", 0.5_f64);

        let proto_edge: proto::Edge = edge.clone().into();
        let back: Edge = proto_edge.into();
        assert_eq!(edge, back);
    }
}