feat(backend): Implement ParameterDataError serialization

Refs: #2

src-tauri/src/common/aws.rs

@@ -1,8 +1,8 @@
 use aws_config::{BehaviorVersion, ConfigLoader};
-use aws_sdk_sts::Client as StsClient;
-use aws_sdk_sts::config::Builder as StsBuilder;
-use aws_sdk_ssm::Client as SsmClient;
 use aws_sdk_ssm::config::Builder as SsmBuilder;
+use aws_sdk_ssm::Client as SsmClient;
+use aws_sdk_sts::config::Builder as StsBuilder;
+use aws_sdk_sts::Client as StsClient;
 
 pub fn localstack_endpoint() -> Option<String> {
     match std::env::var("LOCALSTACK_ENDPOINT") {

src-tauri/src/lib.rs

@@ -1,4 +1,4 @@
 mod common;
 pub mod credentials;
-pub mod profiles;
 pub mod parameters;
+pub mod profiles;

src-tauri/src/parameters.rs

@@ -1,2 +1,2 @@
 pub mod core;
-pub mod infrastructure;
+pub mod infrastructure;

src-tauri/src/parameters/core.rs

@@ -1,4 +1,4 @@
 pub mod api;
 pub mod domain;
 pub mod error;
-pub mod spi;
+pub mod spi;

src-tauri/src/parameters/core/api.rs

@@ -1,11 +1,16 @@
 use async_trait::async_trait;
 #[cfg(test)]
 use mockall::automock;
+
 use crate::parameters::core::domain::Parameter;
 use crate::parameters::core::error::ParameterDataError;
 
 #[cfg_attr(test, automock)]
 #[async_trait]
 pub trait ParameterDataAPI: Send + Sync {
-    async fn get_parameters(&self, profile_name: &str, page_size: u32) -> error_stack::Result<Vec<Parameter>, ParameterDataError>;
-}
+    async fn get_parameters(
+        &self,
+        profile_name: &str,
+        page_size: u32,
+    ) -> error_stack::Result<Vec<Parameter>, ParameterDataError>;
+}

src-tauri/src/parameters/core/error.rs

@@ -1,6 +1,9 @@
 use std::fmt::{Display, Formatter};
 
 use error_stack::Context;
+use serde::ser::SerializeStruct;
+use serde::{Serialize, Serializer};
+use serde_json::json;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum ParameterDataError {
@@ -15,6 +18,116 @@ impl Context for ParameterDataError {}
 
 impl Display for ParameterDataError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        todo!()
+        match self {
+            ParameterDataError::ParameterMetaDataLoadError => {
+                write!(f, "failed to load parameter metadata")
+            }
+            ParameterDataError::ParameterDataLoadError => {
+                write!(f, "failed to load parameter data")
+            }
+            ParameterDataError::InvalidParameter(param) => {
+                write!(f, "invalid parameter: {}", param)
+            }
+            ParameterDataError::UnsupportedParameterType(param_type) => {
+                write!(f, "unsupported parameter type: {}", param_type)
+            }
+            ParameterDataError::UnknownParameterType => write!(f, "unknown parameter type"),
+        }
+    }
+}
+
+impl Serialize for ParameterDataError {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut state = serializer.serialize_struct("ParameterDataError", 1)?;
+        let (code, message) = match self {
+            ParameterDataError::ParameterMetaDataLoadError => {
+                ("ParameterMetaDataLoadError", self.to_string())
+            }
+            ParameterDataError::ParameterDataLoadError => {
+                ("ParameterDataLoadError", self.to_string())
+            }
+            ParameterDataError::InvalidParameter(_) => ("InvalidParameter", self.to_string()),
+            ParameterDataError::UnsupportedParameterType(_) => {
+                ("UnsupportedParameterType", self.to_string())
+            }
+            ParameterDataError::UnknownParameterType => ("UnknownParameterType", self.to_string()),
+        };
+        state.serialize_field("error", &json!({ "code": code, "message": message }))?;
+        state.end()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+
+    use super::*;
+
+    #[test]
+    fn should_serialize_parameter_metadata_load_error() {
+        let error = ParameterDataError::ParameterMetaDataLoadError;
+        let serialized = serde_json::to_string(&error).unwrap();
+        let expected = json!({
+            "error": {
+                "code": "ParameterMetaDataLoadError",
+                "message": "failed to load parameter metadata"
+            }
+        });
+        assert_eq!(serialized, expected.to_string());
+    }
+
+    #[test]
+    fn should_serialize_parameter_data_load_error() {
+        let error = ParameterDataError::ParameterDataLoadError;
+        let serialized = serde_json::to_string(&error).unwrap();
+        let expected = json!({
+            "error": {
+                "code": "ParameterDataLoadError",
+                "message": "failed to load parameter data"
+            }
+        });
+        assert_eq!(serialized, expected.to_string());
+    }
+
+    #[test]
+    fn should_serialize_invalid_parameter() {
+        let error = ParameterDataError::InvalidParameter("param1".to_string());
+        let serialized = serde_json::to_string(&error).unwrap();
+        let expected = json!({
+            "error": {
+                "code": "InvalidParameter",
+                "message": "invalid parameter: param1"
+            }
+        });
+        assert_eq!(serialized, expected.to_string());
+    }
+
+    #[test]
+    fn should_serialize_unsupported_parameter_type() {
+        let error = ParameterDataError::UnsupportedParameterType("type1".to_string());
+        let serialized = serde_json::to_string(&error).unwrap();
+        let expected = json!({
+            "error": {
+                "code": "UnsupportedParameterType",
+                "message": "unsupported parameter type: type1"
+            }
+        });
+        assert_eq!(serialized, expected.to_string());
+    }
+
+    #[test]
+    fn s_serialize_unknown_parameter_type() {
+        let error = ParameterDataError::UnknownParameterType;
+        let serialized = serde_json::to_string(&error).unwrap();
+        let expected = json!({
+            "error": {
+                "code": "UnknownParameterType",
+                "message": "unknown parameter type"
+            }
+        });
+        assert_eq!(serialized, expected.to_string());
     }
 }

src-tauri/src/parameters/infrastructure.rs

@@ -1 +1 @@
-pub mod aws;
+pub mod aws;

src-tauri/src/parameters/infrastructure/aws.rs

@@ -1 +1 @@
-pub mod ssm;
+pub mod ssm;

src-tauri/src/parameters/infrastructure/aws/ssm.rs

@@ -1 +1 @@
-pub mod parameter_store_adapter;
+pub mod parameter_store_adapter;