datafold 0.1.55

A personal database for data sovereignty with AI-powered ingestion
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

use crate::schema::types::SchemaError;
use std::fmt;
use std::io;

/// Unified error type for the entire application.
///
/// This error type centralizes all possible errors that can occur in the application,
/// providing a consistent interface for error handling and propagation.
///
/// Each variant represents a specific category of errors, with associated context
/// to help with debugging and error reporting.
#[derive(Debug)]
pub enum FoldDbError {
    /// Errors related to schema operations
    Schema(SchemaError),

    /// Errors related to database operations
    Database(String),

    /// Errors related to permission checks
    Permission(String),

    /// Errors related to configuration
    Config(String),

    /// Errors related to network operations
    Network(NetworkErrorKind),

    /// Errors related to IO operations
    Io(io::Error),

    /// Errors related to serialization/deserialization
    Serialization(String),

    /// Errors related to payment processing
    Payment(String),

    /// Errors related to security operations
    SecurityError(String),

    /// Other errors that don't fit into the above categories
    Other(String),
}

/// Specific kinds of network errors
#[derive(Debug)]
pub enum NetworkErrorKind {
    /// Error with the network connection
    Connection(String),

    /// Error with node discovery
    Discovery(String),

    /// Error with message serialization/deserialization
    Message(String),

    /// Error with node authentication
    Authentication(String),

    /// Error with trust validation
    Trust(String),

    /// Error with the node configuration
    Config(String),

    /// Timeout error
    Timeout(String),

    /// Protocol error
    Protocol(String),
}

impl fmt::Display for NetworkErrorKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Connection(msg) => write!(f, "Connection error: {}", msg),
            Self::Discovery(msg) => write!(f, "Discovery error: {}", msg),
            Self::Message(msg) => write!(f, "Message error: {}", msg),
            Self::Authentication(msg) => write!(f, "Authentication error: {}", msg),
            Self::Trust(msg) => write!(f, "Trust error: {}", msg),
            Self::Config(msg) => write!(f, "Configuration error: {}", msg),
            Self::Timeout(msg) => write!(f, "Timeout error: {}", msg),
            Self::Protocol(msg) => write!(f, "Protocol error: {}", msg),
        }
    }
}

impl fmt::Display for FoldDbError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Schema(err) => write!(f, "Schema error: {}", err),
            Self::Database(msg) => write!(f, "Database error: {}", msg),
            Self::Permission(msg) => write!(f, "Permission error: {}", msg),
            Self::Config(msg) => write!(f, "Configuration error: {}", msg),
            Self::Network(err) => write!(f, "Network error: {}", err),
            Self::Io(err) => write!(f, "IO error: {}", err),
            Self::Serialization(msg) => write!(f, "Serialization error: {}", msg),
            Self::Payment(msg) => write!(f, "Payment error: {}", msg),
            Self::SecurityError(msg) => write!(f, "Security error: {}", msg),
            Self::Other(msg) => write!(f, "Error: {}", msg),
        }
    }
}

impl std::error::Error for FoldDbError {}

/// Conversion from SchemaError to FoldDbError
impl From<SchemaError> for FoldDbError {
    fn from(error: SchemaError) -> Self {
        FoldDbError::Schema(error)
    }
}

/// Conversion from io::Error to FoldDbError
impl From<io::Error> for FoldDbError {
    fn from(error: io::Error) -> Self {
        FoldDbError::Io(error)
    }
}

/// Conversion from serde_json::Error to FoldDbError
impl From<serde_json::Error> for FoldDbError {
    fn from(error: serde_json::Error) -> Self {
        FoldDbError::Serialization(error.to_string())
    }
}

/// Conversion from sled::Error to FoldDbError
impl From<sled::Error> for FoldDbError {
    fn from(error: sled::Error) -> Self {
        FoldDbError::Database(error.to_string())
    }
}

/// Conversion from &str to NetworkErrorKind
impl From<&str> for NetworkErrorKind {
    fn from(msg: &str) -> Self {
        NetworkErrorKind::Protocol(msg.to_string())
    }
}

/// Result type alias for operations that can result in a FoldDbError
pub type FoldDbResult<T> = Result<T, FoldDbError>;