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

//! Centralized error creation to eliminate 145+ instances of duplicate error handling patterns
//!
//! This module consolidates `SchemaError::InvalidData(format!(...))` patterns found throughout the codebase

use crate::schema::types::SchemaError;

/// Centralized factory for creating consistent error messages
pub struct ErrorFactory;

impl ErrorFactory {
    /// Database operation errors - consolidates 20+ duplicate patterns
    pub fn database_error(operation: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!("Database {} failed: {}", operation, error))
    }

    /// Serialization errors - consolidates 15+ duplicate patterns  
    pub fn serialization_error(context: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!("Serialization failed for {}: {}", context, error))
    }

    /// Deserialization errors - consolidates 15+ duplicate patterns
    pub fn deserialization_error(context: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!("Deserialization failed for {}: {}", context, error))
    }

    /// File operation errors - consolidates 10+ duplicate patterns
    pub fn file_error(operation: &str, path: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!(
            "File {} failed for '{}': {}",
            operation, path, error
        ))
    }

    /// Lock acquisition errors - consolidates 8+ duplicate patterns
    pub fn lock_error(resource: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Failed to acquire lock for {}", resource))
    }

    /// Tree operation errors - consolidates 12+ duplicate patterns
    pub fn tree_error(
        operation: &str,
        tree_name: &str,
        error: impl std::fmt::Display,
    ) -> SchemaError {
        SchemaError::InvalidData(format!(
            "Tree {} operation on '{}' failed: {}",
            operation, tree_name, error
        ))
    }

    /// Schema not found errors - consolidates 8+ duplicate patterns
    pub fn schema_not_found(schema_name: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Schema '{}' not found", schema_name))
    }

    /// Field not found errors - consolidates 10+ duplicate patterns
    pub fn field_not_found(schema_name: &str, field_name: &str) -> SchemaError {
        SchemaError::InvalidData(format!(
            "Field '{}' not found in schema '{}'",
            field_name, schema_name
        ))
    }

    /// Transform not found errors - consolidates 5+ duplicate patterns
    pub fn transform_not_found(transform_id: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Transform '{}' not found", transform_id))
    }

    /// Permission denied errors - consolidates 6+ duplicate patterns
    pub fn permission_denied(context: &str, details: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Permission denied for {}: {}", context, details))
    }

    /// Validation errors - consolidates 12+ duplicate patterns
    pub fn validation_error(context: &str, details: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Validation failed for {}: {}", context, details))
    }

    /// Iterator exhausted errors - consolidates 5+ duplicate patterns
    pub fn iterator_error(context: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Iterator exhausted: {}", context))
    }

    /// JSON parsing errors - consolidates 8+ duplicate patterns
    pub fn json_error(operation: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!("JSON {} failed: {}", operation, error))
    }

    /// Conversion errors - consolidates 10+ duplicate patterns
    pub fn conversion_error(from_type: &str, to_type: &str, value: &str) -> SchemaError {
        SchemaError::InvalidData(format!(
            "Cannot convert {} '{}' to {}",
            from_type, value, to_type
        ))
    }

    /// Range schema validation errors - consolidates 6+ duplicate patterns
    pub fn range_schema_error(schema_name: &str, issue: &str) -> SchemaError {
        SchemaError::InvalidData(format!("Range schema '{}' error: {}", schema_name, issue))
    }

    /// Message bus errors - consolidates 5+ duplicate patterns
    pub fn message_bus_error(operation: &str, error: impl std::fmt::Display) -> SchemaError {
        SchemaError::InvalidData(format!("Message bus {} failed: {}", operation, error))
    }

    /// Generic context-aware error - for remaining cases
    pub fn context_error(context: &str, details: &str) -> SchemaError {
        SchemaError::InvalidData(format!("{}: {}", context, details))
    }
}