feat: improve error types and messages by using thiserror

Cargo.toml

@@ -36,6 +36,7 @@ serde = { version = "^1.0.197", features = ["derive"] }
 serde-enum-str = "^0.4.0"
 serde_with = "^3.7.0"
 serde_yaml = "^0.9.34"
+thiserror = "^1.0.57"
 topological-sort = "^0.2.2"
 voca_rs = "^1.15.2"
 wasm-bindgen = "^0.2.92"

src/errors/mod.rs

@@ -1,35 +1,34 @@
-use std::error::Error;
-use std::fmt;
+use thiserror::Error;
 
-#[derive(Debug)]
-pub struct TransmuteError {
-    details: String,
+#[derive(Debug, Error)]
+pub enum Error {
+    #[error("{message}")]
+    ImportInstructionError { message: String },
+    #[error("{message}")]
+    ResourceTranslationError { message: String },
+    #[error("{message}")]
+    SubParseError { message: String },
+    #[error("{message}")]
+    ResourceInstructionError { message: String },
+    #[error("{message}")]
+    ResourceTypeError { message: String },
+    #[error(transparent)]
+    YamlParseError {
+        #[from]
+        err: serde_yaml::Error,
+    },
+    #[error("{language} is not a supported language")]
+    UnsupportedLanguageError { language: String },
+    #[error(transparent)]
+    IOError {
+        #[from]
+        err: std::io::Error,
+    },
+    #[error("{message}")]
+    TypeReferenceError { message: String },
+    #[error("{message}")]
+    PrimitiveError { message: String },
 }
 
-impl TransmuteError {
-    #[inline(always)]
-    pub(crate) fn new(msg: impl ToString) -> TransmuteError {
-        TransmuteError {
-            details: msg.to_string(),
-        }
-    }
-}
-
-impl From<serde_yaml::Error> for TransmuteError {
-    #[inline]
-    fn from(val: serde_yaml::Error) -> Self {
-        TransmuteError::new(val)
-    }
-}
-
-impl fmt::Display for TransmuteError {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "TransmuteError: {}", self.details)
-    }
-}
-
-impl Error for TransmuteError {}
-
 #[cfg(test)]
 mod tests;

src/errors/tests.rs

@@ -1,19 +1,72 @@
 use serde::de::Error;
 
-use super::*;
+#[test]
+fn test_import_instruction_error() {
+    let error = crate::Error::ImportInstructionError {
+        message: "Import instruction error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Import instruction error");
+}
+
+#[test]
+fn test_resource_translation_error() {
+    let error = crate::Error::ResourceTranslationError {
+        message: "Resource instruction error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Resource instruction error");
+}
 
 #[test]
-fn test_transmute_error() {
-    let error = TransmuteError::new("Test error message");
+fn test_sub_parse_error() {
+    let error = crate::Error::SubParseError {
+        message: "Sub parse error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Sub parse error");
+}
+
+#[test]
+fn test_resource_instruction_error() {
+    let error = crate::Error::ResourceInstructionError {
+        message: "Resource instruction error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Resource instruction error");
+}
 
-    assert_eq!(error.details, "Test error message");
-    assert_eq!(error.to_string(), "TransmuteError: Test error message");
+#[test]
+fn test_resource_type_error() {
+    let error = crate::Error::ResourceTypeError {
+        message: "Resource type error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Resource type error");
 }
 
 #[test]
-fn test_transmute_error_from() {
+fn test_yaml_parse_error() {
     let yaml_error = serde_yaml::Error::custom("YAML parsing error");
-    let transmute_error: TransmuteError = yaml_error.into();
+    let error: crate::Error = yaml_error.into();
+    assert_eq!(error.to_string(), "YAML parsing error");
+}
+
+#[test]
+fn test_unsupported_language_error() {
+    let error = crate::Error::UnsupportedLanguageError {
+        language: "php".to_string(),
+    };
+    assert_eq!(error.to_string(), "php is not a supported language");
+}
 
-    assert_eq!(transmute_error.details, "YAML parsing error");
+#[test]
+fn test_type_reference_error() {
+    let error = crate::Error::TypeReferenceError {
+        message: "Type reference error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Type reference error");
+}
+
+#[test]
+fn test_primitive_error() {
+    let error = crate::Error::PrimitiveError {
+        message: "Primitive error".to_string(),
+    };
+    assert_eq!(error.to_string(), "Primitive error");
 }

src/ir/constructor/mod.rs

@@ -2,7 +2,7 @@ use crate::{parser::parameters::Parameter, Hasher};
 use indexmap::IndexMap;
 use voca_rs::case::camel_case;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Constructor {
     pub inputs: Vec<ConstructorParameter>,
 }
@@ -43,7 +43,7 @@ impl Constructor {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct ConstructorParameter {
     pub name: String,
     pub description: Option<String>,

src/ir/importer/mod.rs

@@ -3,7 +3,7 @@ use std::collections::HashSet;
 use indexmap::IndexMap;
 
 use crate::parser::resource::ResourceAttributes;
-use crate::{Hasher, TransmuteError};
+use crate::{Error, Hasher};
 
 // ImportInstruction look something like:
 // import * as $name from '$path[0]/$path[1]...';
@@ -17,7 +17,7 @@ pub struct ImportInstruction {
 impl ImportInstruction {
     pub(super) fn from(
         parse_tree: &IndexMap<String, ResourceAttributes, Hasher>,
-    ) -> Result<Vec<Self>, TransmuteError> {
+    ) -> Result<Vec<Self>, Error> {
         let mut type_names = HashSet::new();
         for (_, resource) in parse_tree {
             let type_name = &resource.resource_type;
@@ -29,9 +29,9 @@ impl ImportInstruction {
                 }) {
                 triple
             } else {
-                return Err(TransmuteError::new(format!(
-                    "invalid resource type name: {type_name}"
-                )));
+                return Err(Error::ImportInstructionError {
+                    message: format!("Invalid resource type name: {type_name}"),
+                });
             };
 
             let service_name = if service.to_string().to_lowercase().eq("serverless") {
@@ -70,3 +70,6 @@ struct TypeName {
     organization: String,
     service: Option<String>,
 }
+
+#[cfg(test)]
+mod tests;

src/ir/importer/tests.rs

@@ -0,0 +1,24 @@
+use indexmap::IndexMap;
+
+use crate::parser::resource::ResourceAttributes;
+
+use super::ImportInstruction;
+
+#[test]
+fn test_invalid_resource_type_name() {
+    let resource_attributes = ResourceAttributes {
+        resource_type: "AWS:Invalid:Resource:Type".to_string(),
+        condition: Option::None,
+        metadata: Option::None,
+        depends_on: vec![],
+        update_policy: Option::None,
+        deletion_policy: Option::None,
+        properties: IndexMap::new(),
+    };
+    let parse_tree = IndexMap::from([("Resource".to_string(), resource_attributes)]);
+    let import_instruction = ImportInstruction::from(&parse_tree).unwrap_err();
+    assert_eq!(
+        "Invalid resource type name: AWS:Invalid:Resource:Type",
+        import_instruction.to_string()
+    );
+}

src/ir/mod.rs

@@ -7,7 +7,7 @@ use crate::ir::importer::ImportInstruction;
 use crate::ir::mappings::MappingInstruction;
 use crate::ir::outputs::OutputInstruction;
 use crate::ir::resources::ResourceInstruction;
-use crate::{CloudformationParseTree, TransmuteError};
+use crate::{CloudformationParseTree, Error};
 
 use self::reference::{Origin, PseudoParameter};
 
@@ -20,7 +20,7 @@ pub mod reference;
 pub mod resources;
 pub mod sub;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct CloudformationProgramIr {
     pub description: Option<String>,
     pub transforms: Vec<String>,
@@ -40,7 +40,7 @@ impl CloudformationProgramIr {
     pub fn from(
         parse_tree: CloudformationParseTree,
         schema: &Schema,
-    ) -> Result<CloudformationProgramIr, TransmuteError> {
+    ) -> Result<CloudformationProgramIr, Error> {
         let origins = ReferenceOrigins::new(&parse_tree);
 
         Ok(CloudformationProgramIr {

src/ir/outputs/mod.rs

@@ -5,7 +5,7 @@ use crate::ir::resources::{ResourceIr, ResourceTranslator};
 use crate::parser::output::Output;
 use crate::parser::resource::ResourceValue;
 use crate::util::Hasher;
-use crate::TransmuteError;
+use crate::Error;
 
 use super::ReferenceOrigins;
 
@@ -23,7 +23,7 @@ impl OutputInstruction {
         parse_tree: IndexMap<String, Output, Hasher>,
         schema: &Schema,
         origins: &ReferenceOrigins,
-    ) -> Result<Vec<Self>, TransmuteError> {
+    ) -> Result<Vec<Self>, Error> {
         let mut list = Vec::with_capacity(parse_tree.len());
 
         for (name, output) in parse_tree {