interstellar 0.2.0

A high-performance graph database with Gremlin-style traversals and GQL query language
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

//! Error types for GraphSON operations.

use thiserror::Error;

/// Errors that can occur during GraphSON operations.
#[derive(Debug, Error)]
pub enum GraphSONError {
    /// JSON parsing failed
    #[error("JSON parse error: {0}")]
    JsonParse(#[from] serde_json::Error),

    /// Unknown type tag encountered
    #[error("unknown type tag: {0}")]
    UnknownTypeTag(String),

    /// Missing required field
    #[error("missing required field: {0}")]
    MissingField(String),

    /// Invalid value for type
    #[error("invalid value for type {type_tag}: {message}")]
    InvalidValue {
        /// The GraphSON type tag
        type_tag: String,
        /// Description of the error
        message: String,
    },

    /// Duplicate vertex ID
    #[error("duplicate vertex ID: {0}")]
    DuplicateVertexId(u64),

    /// Duplicate edge ID
    #[error("duplicate edge ID: {0}")]
    DuplicateEdgeId(u64),

    /// Referenced vertex not found
    #[error("vertex not found: {0}")]
    VertexNotFound(u64),

    /// Map key is not a string
    #[error("map keys must be strings, found: {0}")]
    NonStringMapKey(String),

    /// Schema validation failed
    #[error("schema validation error: {0}")]
    SchemaValidation(String),

    /// I/O error
    #[error("I/O error: {0}")]
    Io(#[from] std::io::Error),
}

/// A specialized Result type for GraphSON operations.
pub type Result<T> = std::result::Result<T, GraphSONError>;

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

    #[test]
    fn test_error_display() {
        let err = GraphSONError::UnknownTypeTag("g:Unknown".to_string());
        assert_eq!(err.to_string(), "unknown type tag: g:Unknown");

        let err = GraphSONError::InvalidValue {
            type_tag: "g:Int64".to_string(),
            message: "expected integer".to_string(),
        };
        assert_eq!(
            err.to_string(),
            "invalid value for type g:Int64: expected integer"
        );

        let err = GraphSONError::VertexNotFound(42);
        assert_eq!(err.to_string(), "vertex not found: 42");
    }

    #[test]
    fn test_json_error_conversion() {
        let json_err: std::result::Result<serde_json::Value, _> =
            serde_json::from_str("not valid json");
        let err: GraphSONError = json_err.unwrap_err().into();
        assert!(matches!(err, GraphSONError::JsonParse(_)));
    }

    #[test]
    fn test_io_error_conversion() {
        let io_err = std::io::Error::new(std::io::ErrorKind::NotFound, "file not found");
        let err: GraphSONError = io_err.into();
        assert!(matches!(err, GraphSONError::Io(_)));
    }
}