feat: add API backing functions

- Added decoder and tests
- Added tests for error types

Author: pmorris-dev

Cargo.lock

@@ -23,6 +23,7 @@ futures-core = "0.3.31"
 time = "0.3.44"
 tokio = { version = "1.48.0", features = ["sync"] }
 indexmap = { version = "2.12.1", features = ["serde"] }
+base64 = "0.22.1"
 
 # SQLx for types and queries (time feature enables datetime type decoding)
 sqlx = { version = "0.8.6", features = ["sqlite", "json", "time", "runtime-tokio"] }

Cargo.toml

@@ -0,0 +1,157 @@
+use serde_json::Value as JsonValue;
+use sqlx::sqlite::SqliteValueRef;
+use sqlx::{TypeInfo, Value, ValueRef};
+use time::PrimitiveDateTime;
+
+use crate::Error;
+
+/// Convert a SQLite value to a JSON value.
+///
+/// This function handles the type conversion from SQLite's native types
+/// to JSON-compatible representations.
+pub fn to_json(value: SqliteValueRef) -> Result<JsonValue, Error> {
+   if value.is_null() {
+      return Ok(JsonValue::Null);
+   }
+
+   let column_type = value.type_info();
+
+   // Handle types based on SQLite's type affinity
+   let result = match column_type.name() {
+      "TEXT" => {
+         if let Ok(v) = value.to_owned().try_decode::<String>() {
+            JsonValue::String(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "REAL" => {
+         if let Ok(v) = value.to_owned().try_decode::<f64>() {
+            JsonValue::from(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "INTEGER" | "NUMERIC" => {
+         if let Ok(v) = value.to_owned().try_decode::<i64>() {
+            JsonValue::Number(v.into())
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "BOOLEAN" => {
+         if let Ok(v) = value.to_owned().try_decode::<bool>() {
+            JsonValue::Bool(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "DATE" => {
+         // SQLite stores dates as TEXT in ISO 8601 format
+         if let Ok(v) = value.to_owned().try_decode::<String>() {
+            JsonValue::String(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "TIME" => {
+         // SQLite stores time as TEXT in HH:MM:SS format
+         if let Ok(v) = value.to_owned().try_decode::<String>() {
+            JsonValue::String(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "DATETIME" => {
+         // Try to decode as PrimitiveDateTime
+         if let Ok(dt) = value.to_owned().try_decode::<PrimitiveDateTime>() {
+            JsonValue::String(dt.to_string())
+         } else if let Ok(v) = value.to_owned().try_decode::<String>() {
+            // Fall back to string representation
+            JsonValue::String(v)
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "BLOB" => {
+         if let Ok(blob) = value.to_owned().try_decode::<Vec<u8>>() {
+            // Encode binary data as base64 for JSON serialization
+            JsonValue::String(base64_encode(&blob))
+         } else {
+            JsonValue::Null
+         }
+      }
+
+      "NULL" => JsonValue::Null,
+
+      _ => {
+         // For unknown types, try to decode as text
+         if let Ok(text) = value.to_owned().try_decode::<String>() {
+            JsonValue::String(text)
+         } else {
+            return Err(Error::UnsupportedDatatype(format!(
+               "Unknown SQLite type: {}",
+               column_type.name()
+            )));
+         }
+      }
+   };
+
+   Ok(result)
+}
+
+/// Base64 encode binary data for JSON serialization.
+///
+/// SQLite BLOB columns are encoded as base64 strings when serialized to JSON,
+/// as JSON does not have a native binary type.
+fn base64_encode(data: &[u8]) -> String {
+   use std::io::Write;
+
+   let mut buf = Vec::new();
+   {
+      let mut encoder =
+         base64::write::EncoderWriter::new(&mut buf, &base64::engine::general_purpose::STANDARD);
+      encoder.write_all(data).unwrap();
+   }
+   String::from_utf8(buf).unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn test_base64_encode() {
+      assert_eq!(base64_encode(b"hello"), "aGVsbG8=");
+      assert_eq!(base64_encode(&[1, 2, 3, 4, 5]), "AQIDBAU=");
+      assert_eq!(base64_encode(&[]), "");
+   }
+
+   #[test]
+   fn test_base64_encode_binary() {
+      // Test with binary data including null bytes
+      assert_eq!(base64_encode(&[0, 0, 0]), "AAAA");
+      assert_eq!(base64_encode(&[255, 255, 255]), "////");
+   }
+
+   #[test]
+   fn test_base64_encode_large() {
+      // Test with larger binary data
+      let data: Vec<u8> = (0..255).collect();
+      let encoded = base64_encode(&data);
+      assert!(!encoded.is_empty());
+      // Verify it's valid base64 (only contains valid chars)
+      assert!(
+         encoded
+            .chars()
+            .all(|c| c.is_alphanumeric() || c == '+' || c == '/' || c == '=')
+      );
+   }
+}

src/decode.rs

@@ -87,3 +87,97 @@ impl Serialize for Error {
       response.serialize(serializer)
    }
 }
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+
+   #[test]
+   fn test_error_code_database_not_loaded() {
+      let err = Error::DatabaseNotLoaded("test.db".into());
+      assert_eq!(err.error_code(), "DATABASE_NOT_LOADED");
+   }
+
+   #[test]
+   fn test_error_code_invalid_path() {
+      let err = Error::InvalidPath("/bad/path".into());
+      assert_eq!(err.error_code(), "INVALID_PATH");
+   }
+
+   #[test]
+   fn test_error_code_unsupported_datatype() {
+      let err = Error::UnsupportedDatatype("WEIRD_TYPE".into());
+      assert_eq!(err.error_code(), "UNSUPPORTED_DATATYPE");
+   }
+
+   #[test]
+   fn test_error_code_read_only_query() {
+      let err = Error::ReadOnlyQueryInExecute;
+      assert_eq!(err.error_code(), "READ_ONLY_QUERY_IN_EXECUTE");
+   }
+
+   #[test]
+   fn test_error_code_multiple_rows() {
+      let err = Error::MultipleRowsReturned(5);
+      assert_eq!(err.error_code(), "MULTIPLE_ROWS_RETURNED");
+   }
+
+   #[test]
+   fn test_error_serialization_structure() {
+      let err = Error::DatabaseNotLoaded("mydb.db".into());
+      let json = serde_json::to_value(&err).unwrap();
+
+      // Verify structure has both code and message fields
+      assert!(json.is_object());
+      assert!(json.get("code").is_some());
+      assert!(json.get("message").is_some());
+   }
+
+   #[test]
+   fn test_error_serialization_database_not_loaded() {
+      let err = Error::DatabaseNotLoaded("mydb.db".into());
+      let json = serde_json::to_value(&err).unwrap();
+
+      assert_eq!(json["code"], "DATABASE_NOT_LOADED");
+      assert!(json["message"].as_str().unwrap().contains("mydb.db"));
+      assert!(json["message"].as_str().unwrap().contains("not loaded"));
+   }
+
+   #[test]
+   fn test_error_serialization_invalid_path() {
+      let err = Error::InvalidPath("/bad/path".into());
+      let json = serde_json::to_value(&err).unwrap();
+
+      assert_eq!(json["code"], "INVALID_PATH");
+      assert!(json["message"].as_str().unwrap().contains("/bad/path"));
+   }
+
+   #[test]
+   fn test_error_serialization_multiple_rows() {
+      let err = Error::MultipleRowsReturned(3);
+      let json = serde_json::to_value(&err).unwrap();
+
+      assert_eq!(json["code"], "MULTIPLE_ROWS_RETURNED");
+      let message = json["message"].as_str().unwrap();
+      assert!(message.contains("3 rows"));
+      assert!(message.contains("0 or 1"));
+   }
+
+   #[test]
+   fn test_error_message_format() {
+      // Verify error messages are descriptive
+      let err = Error::MultipleRowsReturned(5);
+      let message = err.to_string();
+      assert!(message.contains("fetchOne()"));
+      assert!(message.contains("5 rows"));
+      assert!(message.contains("expected 0 or 1"));
+   }
+
+   #[test]
+   fn test_read_only_error_message() {
+      let err = Error::ReadOnlyQueryInExecute;
+      let message = err.to_string();
+      assert!(message.contains("execute()"));
+      assert!(message.contains("fetchX()"));
+   }
+}