diesel-guard 0.2.0

Catch unsafe PostgreSQL migrations in Diesel before they take down production
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

use miette::{Diagnostic, SourceSpan};
use thiserror::Error;

#[derive(Error, Debug, Diagnostic)]
pub enum DieselGuardError {
    #[error("Failed to parse SQL: {msg}")]
    #[diagnostic(
        code(diesel_guard::parse_error),
        help("Check that your SQL syntax is valid PostgreSQL"),
        url("https://www.postgresql.org/docs/current/sql-syntax.html")
    )]
    ParseError {
        msg: String,
        #[source_code]
        src: Option<String>,
        #[label("problematic SQL")]
        span: Option<SourceSpan>,
    },

    #[error("Failed to read file")]
    #[diagnostic(
        code(diesel_guard::io_error),
        help("Ensure the file exists and you have read permissions")
    )]
    IoError(#[from] std::io::Error),

    #[error("Failed to traverse directory")]
    #[diagnostic(
        code(diesel_guard::walkdir_error),
        help("Check directory permissions and path validity")
    )]
    WalkDirError(#[from] walkdir::Error),

    #[error("Configuration error")]
    #[diagnostic(
        code(diesel_guard::config_error),
        help("Run 'diesel-guard init' to create a valid configuration file")
    )]
    ConfigError(#[from] crate::config::ConfigError),
}

impl DieselGuardError {
    /// Create a simple parse error with just a message (backward compatible)
    pub fn parse_error(msg: impl Into<String>) -> Self {
        Self::ParseError {
            msg: msg.into(),
            src: None,
            span: None,
        }
    }

    /// Create a parse error with source code context
    pub fn parse_error_with_source(
        msg: impl Into<String>,
        src: impl Into<String>,
        span: Option<SourceSpan>,
    ) -> Self {
        Self::ParseError {
            msg: msg.into(),
            src: Some(src.into()),
            span,
        }
    }
}

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