neon/types_impl/extract/
error.rs

1use std::{convert::Infallible, error, fmt, marker::PhantomData};
2
3use crate::{
4    context::{Context, Cx},
5    result::JsResult,
6    types::{
7        extract::{private, TryIntoJs},
8        JsError, JsValue, Value,
9    },
10};
11
12type BoxError = Box<dyn error::Error + Send + Sync + 'static>;
13
14/// Error returned when a JavaScript value is not the type expected
15pub struct TypeExpected<T: Value>(PhantomData<T>);
16
17impl<T: Value> TypeExpected<T> {
18    pub(super) fn new() -> Self {
19        Self(PhantomData)
20    }
21}
22
23impl<T: Value> fmt::Display for TypeExpected<T> {
24    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
25        write!(f, "expected {}", T::name())
26    }
27}
28
29impl<T: Value> fmt::Debug for TypeExpected<T> {
30    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
31        f.debug_tuple("TypeExpected").field(&T::name()).finish()
32    }
33}
34
35impl<T: Value> error::Error for TypeExpected<T> {}
36
37impl<'cx, T: Value> TryIntoJs<'cx> for TypeExpected<T> {
38    type Value = JsError;
39
40    fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
41        JsError::type_error(cx, self.to_string())
42    }
43}
44
45impl<T: Value> private::Sealed for TypeExpected<T> {}
46
47impl<'cx> TryIntoJs<'cx> for Infallible {
48    type Value = JsValue;
49
50    fn try_into_js(self, _: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
51        unreachable!()
52    }
53}
54
55impl private::Sealed for Infallible {}
56
57#[derive(Debug)]
58/// Error that implements [`TryIntoJs`] and can produce specific error types.
59///
60/// [`Error`] implements [`From`] for most error types, allowing ergonomic error handling in
61/// exported functions with the `?` operator.
62///
63/// ### Example
64///
65/// ```
66/// use neon::types::extract::Error;
67///
68/// #[neon::export]
69/// fn read_file(path: String) -> Result<String, Error> {
70///     let contents = std::fs::read_to_string(path)?;
71///     Ok(contents)
72/// }
73/// ```
74pub struct Error {
75    cause: BoxError,
76    kind: Option<ErrorKind>,
77}
78
79#[derive(Debug)]
80enum ErrorKind {
81    Error,
82    RangeError,
83    TypeError,
84}
85
86impl Error {
87    /// Create a new [`Error`] from a `cause`
88    pub fn new<E>(cause: E) -> Self
89    where
90        E: Into<BoxError>,
91    {
92        Self::create(ErrorKind::Error, cause)
93    }
94
95    /// Create a `RangeError`
96    pub fn range_error<E>(cause: E) -> Self
97    where
98        E: Into<BoxError>,
99    {
100        Self::create(ErrorKind::RangeError, cause)
101    }
102
103    /// Create a `TypeError`
104    pub fn type_error<E>(cause: E) -> Self
105    where
106        E: Into<BoxError>,
107    {
108        Self::create(ErrorKind::TypeError, cause)
109    }
110
111    /// Check if error is a `RangeError`
112    pub fn is_range_error(&self) -> bool {
113        matches!(self.kind, Some(ErrorKind::RangeError))
114    }
115
116    /// Check if error is a `TypeError`
117    pub fn is_type_error(&self) -> bool {
118        matches!(self.kind, Some(ErrorKind::TypeError))
119    }
120
121    /// Get a reference to the underlying `cause`
122    pub fn cause(&self) -> &BoxError {
123        &self.cause
124    }
125
126    /// Extract the `std::error::Error` cause
127    pub fn into_cause(self) -> BoxError {
128        self.cause
129    }
130
131    fn create<E>(kind: ErrorKind, cause: E) -> Self
132    where
133        E: Into<BoxError>,
134    {
135        Self {
136            cause: cause.into(),
137            kind: Some(kind),
138        }
139    }
140}
141
142// Blanket impl allow for ergonomic `?` error handling from typical error types (including `anyhow`)
143impl<E> From<E> for Error
144where
145    E: Into<BoxError>,
146{
147    fn from(cause: E) -> Self {
148        Self::new(cause)
149    }
150}
151
152impl fmt::Display for Error {
153    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
154        write!(f, "{:?}: {}", self.kind, self.cause)
155    }
156}
157
158// N.B.: `TryFromJs` is not included. If Neon were to add support for additional error types,
159// this would be a *breaking* change. We will wait for user demand before providing this feature.
160impl<'cx> TryIntoJs<'cx> for Error {
161    type Value = JsError;
162
163    fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
164        let message = self.cause.to_string();
165
166        match self.kind {
167            Some(ErrorKind::RangeError) => cx.range_error(message),
168            Some(ErrorKind::TypeError) => cx.type_error(message),
169            _ => cx.error(message),
170        }
171    }
172}
neon/types_impl/extract/error.rs

neon/types_impl/extract/
error.rs
