grounddb 1.2.0

Schema-driven database that stores data as Markdown files — SQL views, file watching, typed Rust codegen
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

use thiserror::Error;

#[derive(Error, Debug)]
pub enum GroundDbError {
    #[error("Schema error: {0}")]
    Schema(String),

    #[error("Validation error: {0}")]
    Validation(String),

    #[error("Document not found: {collection}/{id}")]
    NotFound { collection: String, id: String },

    #[error("Collection not found: {name}")]
    CollectionNotFound { name: String },

    #[error("View not found: {name}")]
    ViewNotFound { name: String },

    #[error("Field validation failed for {collection}.{field}: {message}")]
    FieldValidation {
        collection: String,
        field: String,
        message: String,
    },

    #[error("Path conflict: {path}")]
    PathConflict { path: String },

    #[error("Referential integrity violation: {0}")]
    ReferentialIntegrity(String),

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

    #[error("YAML error: {0}")]
    Yaml(#[from] serde_yaml::Error),

    #[error("JSON error: {0}")]
    Json(#[from] serde_json::Error),

    #[error("SQLite error: {0}")]
    Sqlite(#[from] rusqlite::Error),

    #[error("SQL parse error: {0}")]
    SqlParse(String),

    #[error("Migration error: {0}")]
    Migration(String),

    #[error("{0}")]
    Other(String),
}

pub type Result<T> = std::result::Result<T, GroundDbError>;

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

    #[test]
    fn not_found_display_includes_collection_and_id() {
        let err = GroundDbError::NotFound {
            collection: "users".into(),
            id: "u_42".into(),
        };
        assert_eq!(err.to_string(), "Document not found: users/u_42");
    }

    #[test]
    fn collection_not_found_display_carries_name() {
        let err = GroundDbError::CollectionNotFound {
            name: "ghosts".into(),
        };
        assert_eq!(err.to_string(), "Collection not found: ghosts");
    }

    #[test]
    fn view_not_found_display_carries_name() {
        let err = GroundDbError::ViewNotFound {
            name: "by_status".into(),
        };
        assert_eq!(err.to_string(), "View not found: by_status");
    }

    #[test]
    fn field_validation_display_includes_context() {
        let err = GroundDbError::FieldValidation {
            collection: "users".into(),
            field: "email".into(),
            message: "must contain @".into(),
        };
        assert_eq!(
            err.to_string(),
            "Field validation failed for users.email: must contain @"
        );
    }

    #[test]
    fn typed_variants_allow_programmatic_introspection() {
        let err = GroundDbError::CollectionNotFound {
            name: "x".into(),
        };
        match err {
            GroundDbError::CollectionNotFound { name } => assert_eq!(name, "x"),
            _ => panic!("wrong variant"),
        }
    }
}