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

use connector::error::ConnectorError;
use psl::diagnostics::Diagnostics;
use query_core::CoreError;
use thiserror::Error;

#[derive(Debug, Error)]
#[allow(clippy::enum_variant_names)]
pub enum PrismaError {
    #[error(transparent)]
    CoreError(Box<CoreError>),

    #[error(transparent)]
    JsonDecodeError(anyhow::Error),

    #[error("{}", _0)]
    ConfigurationError(String),

    #[error(transparent)]
    ConnectorError(Box<ConnectorError>),

    #[error("{:?}", _0)]
    ConversionError(Diagnostics, String),

    #[error(transparent)]
    IOError(anyhow::Error),

    #[error("Error in data model: {:?}", _0)]
    DatamodelError(Diagnostics),
}

impl From<PrismaError> for user_facing_errors::Error {
    fn from(err: PrismaError) -> Self {
        use std::fmt::Write as _;

        match err {
            PrismaError::ConnectorError(connector_err) => match *connector_err {
                ConnectorError {
                    user_facing_error: Some(err),
                    ..
                } => err.into(),
                other => {
                    let err = PrismaError::ConnectorError(Box::new(other));
                    user_facing_errors::Error::new_non_panic_with_current_backtrace(err.to_string())
                }
            },
            PrismaError::ConversionError(errors, dml_string) => {
                let mut full_error = errors.to_pretty_string("schema.prisma", &dml_string);
                write!(full_error, "\nValidation Error Count: {}", errors.errors().len()).unwrap();

                user_facing_errors::Error::from(user_facing_errors::KnownError::new(
                    user_facing_errors::common::SchemaParserError { full_error },
                ))
            }
            other => user_facing_errors::Error::new_non_panic_with_current_backtrace(other.to_string()),
        }
    }
}

impl PrismaError {
    pub fn render_as_json(self) -> Result<(), anyhow::Error> {
        use std::io::Write as _;

        let error = user_facing_errors::Error::from(self);

        // Because of how the node frontend works (stderr.on('data', ...)), we want to emit one clean JSON message on a single line at once.
        let stderr = std::io::stderr();
        let locked_stderr = stderr.lock();
        let mut writer = std::io::LineWriter::new(locked_stderr);
        serde_json::to_writer(&mut writer, &error)?;
        writeln!(&mut writer)?;
        writer.flush()?;

        Ok(())
    }
}

impl From<CoreError> for PrismaError {
    fn from(e: CoreError) -> Self {
        match e {
            CoreError::ConnectorError(e) => Self::ConnectorError(Box::new(e)),
            CoreError::ConfigurationError(message) => Self::ConfigurationError(message),
            _ => PrismaError::CoreError(Box::new(e)),
        }
    }
}

impl From<Diagnostics> for PrismaError {
    fn from(e: Diagnostics) -> Self {
        PrismaError::DatamodelError(e)
    }
}

impl From<url::ParseError> for PrismaError {
    fn from(e: url::ParseError) -> PrismaError {
        PrismaError::ConfigurationError(format!("Error parsing connection string: {e}"))
    }
}

impl From<connection_string::Error> for PrismaError {
    fn from(e: connection_string::Error) -> PrismaError {
        PrismaError::ConfigurationError(format!("Error parsing connection string: {e}"))
    }
}

impl From<serde_json::error::Error> for PrismaError {
    fn from(e: serde_json::error::Error) -> PrismaError {
        PrismaError::JsonDecodeError(e.into())
    }
}

impl From<std::io::Error> for PrismaError {
    fn from(e: std::io::Error) -> PrismaError {
        PrismaError::IOError(e.into())
    }
}

impl From<std::string::FromUtf8Error> for PrismaError {
    fn from(e: std::string::FromUtf8Error) -> PrismaError {
        PrismaError::IOError(e.into())
    }
}

impl From<base64::DecodeError> for PrismaError {
    fn from(e: base64::DecodeError) -> PrismaError {
        PrismaError::ConfigurationError(format!("Invalid base64: {e}"))
    }
}

impl From<ConnectorError> for PrismaError {
    fn from(e: ConnectorError) -> PrismaError {
        PrismaError::ConnectorError(Box::new(e))
    }
}