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,152 @@
+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,98 @@ impl Serialize for Error {
       response.serialize(serializer)
    }
 }
+
+#[cfg(test)]
+mod tests {
+   use super::*;
+   use serde_json;
+
+   #[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()"));
+   }
+}