wip: ft_sdk::Required handles body better

CHANGELOG.md

@@ -1,5 +1,12 @@
 # ChangeLog
 
+## Unreleased
+
+### ft-sdk: 0.6.4
+
+- `ft_sdk::Required<T>`: if `T` is not `String` and incoming body is
+  `serde_json::Value::String`, we handle it still.
+
 ## 22nd Mar 2025
 
 ### ft-sdk: 0.6.3

Cargo.toml

@@ -34,7 +34,7 @@ bytes = "1"
 chrono = { version = "0.4", default-features = false, features = ["serde"] }
 diesel = { version = "2.2.4", features = ["serde_json"] }
 ft-derive = { path = "ft-derive", version = "0.2.1" }
-ft-sdk = { path = "ft-sdk", version = "0.6.3" }
+ft-sdk = { path = "ft-sdk", version = "0.6.4" }
 ft-sys = { path = "ft-sys", version = "0.3.0" }
 ft-sys-shared = { path = "ft-sys-shared", version = "0.2.1" }
 http = "1"

ft-sdk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ft-sdk"
-version = "0.6.3"
+version = "0.6.4"
 description = "ft-sdk: SDK for building FifthTry Applications"
 authors.workspace = true
 edition.workspace = true

ft-sdk/src/auth/mod.rs

@@ -5,7 +5,7 @@ mod utils;
 
 pub use ft_sys_shared::SESSION_KEY;
 pub use schema::fastn_user;
-pub use utils::{user_data_by_query, Counter};
+pub use utils::{Counter, user_data_by_query};
 
 #[derive(Clone, Debug)]
 pub struct UserId(pub i64);

ft-sdk/src/auth/utils.rs

@@ -28,7 +28,7 @@ pub fn user_data_by_query(
         Ok(v) if v.len() > 1 => return Err(ft_sdk::auth::UserDataError::MultipleRowsFound),
         Ok(mut v) => v.pop().unwrap(),
         Err(diesel::result::Error::NotFound) => {
-            return Err(ft_sdk::auth::UserDataError::NoDataFound)
+            return Err(ft_sdk::auth::UserDataError::NoDataFound);
         }
         Err(e) => return Err(ft_sdk::auth::UserDataError::DatabaseError(e)),
     };

ft-sdk/src/data.rs

@@ -112,7 +112,7 @@ pub fn binary<S: AsRef<str>>(content: bytes::Bytes, content_type: S) -> Result {
 /// Adding cookie with redirect headers does not work across browsers. This helper creates
 /// a 200-OK response, with an HTML meta-refresh tag to redirect the browser.
 ///
-/// ```rust
+/// ```rust,ignore
 ///  let cookie = cookie::Cookie::build((ft_sdk::auth::SESSION_KEY, "some-uniq-key"))
 ///         .domain("127.0.0.1")
 ///         .path("")

ft-sdk/src/from_request/handler.rs

@@ -3,6 +3,7 @@
 pub fn handle<T, O: Into<Result<http::Response<bytes::Bytes>, ft_sdk::Error>>, H: Handler<T, O>>(
     h: H,
 ) {
+    ft_sdk::println!("Handling request with handler");
     let req = match current_request() {
         Ok(v) => v,
         Err(e) => {

ft-sdk/src/from_request/required.rs

@@ -56,16 +56,24 @@ impl<const KEY: &'static str, T: serde::de::DeserializeOwned + 'static> ft_sdk::
     fn from_request(req: &http::Request<serde_json::Value>) -> Result<Self, ft_sdk::Error> {
         match req.body() {
             serde_json::Value::Null => {
+                ft_sdk::println!("body is Null, expected Object");
                 Err(ft_sdk::single_error(KEY, "body is Null, expected Object").into())
             }
             serde_json::Value::Object(map) => {
+                ft_sdk::println!("body is Object, checking for key: {}", KEY);
                 if let Some(value) = map.get(KEY) {
+                    ft_sdk::println!("found key: {}", KEY);
                     if std::any::TypeId::of::<T>() == std::any::TypeId::of::<String>() {
+                        ft_sdk::println!("type is String, checking if empty");
                         if let serde_json::Value::String(s) = value {
                             if s.is_empty() {
                                 return Err(ft_sdk::single_error(KEY, "field is empty").into());
                             }
                         }
+                    } else if let serde_json::Value::String(s) = value {
+                        // if the Rust type `T` is not String, and yet we have been passed a string,
+                        // we can still deserialize it, just to be nice.
+                        return Ok(serde_json::from_str(s).map(Required)?);
                     }
                     Ok(serde_json::from_value(value.clone()).map(Required)?)
                 } else {

ft-sys/src/diesel_sqlite/bind_collector.rs

@@ -1,7 +1,7 @@
+use diesel::QueryResult;
 use diesel::query_builder::BindCollector;
 use diesel::serialize::{IsNull, Output};
 use diesel::sql_types::HasSqlType;
-use diesel::QueryResult;
 use ft_sys::diesel_sqlite::backend::Sqlite;
 
 #[derive(Debug, Default, serde::Serialize)]

ft-sys/src/diesel_sqlite/query_builder/insertable.rs

@@ -7,8 +7,8 @@ use diesel::query_builder::{AstPass, QueryId, ValuesClause};
 use diesel::query_builder::{BatchInsert, InsertStatement};
 use diesel::query_dsl::methods::ExecuteDsl;
 use diesel::{QueryResult, Table};
-use ft_sys::diesel_sqlite::Sqlite;
 use ft_sys::SqliteConnection;
+use ft_sys::diesel_sqlite::Sqlite;
 
 // Todo: Add debug and display traits.
 //      Checkout `diesel::query_builder::insert_statement::insert_with_default_for_sqlite` module

ft-sys/src/diesel_sqlite/query_builder/returning.rs

@@ -1,7 +1,7 @@
 use diesel::query_builder::{AstPass, QueryFragment, ReturningClause};
 use diesel::result::QueryResult;
-use ft_sys::diesel_sqlite::backend::SqliteReturningClause;
 use ft_sys::diesel_sqlite::Sqlite;
+use ft_sys::diesel_sqlite::backend::SqliteReturningClause;
 
 impl<Expr> QueryFragment<Sqlite, SqliteReturningClause> for ReturningClause<Expr>
 where

ft-sys/src/diesel_sqlite/types/mod.rs

@@ -5,7 +5,7 @@ mod jsonb;
 use super::{Sqlite, SqliteValue};
 use diesel::deserialize::FromSql;
 use diesel::serialize::{IsNull, Output, ToSql};
-use diesel::{deserialize, serialize, sql_types, Queryable};
+use diesel::{Queryable, deserialize, serialize, sql_types};
 
 impl FromSql<sql_types::Integer, Sqlite> for i32 {
     fn from_sql(value: SqliteValue) -> deserialize::Result<Self> {

ft-sys/src/env.rs

@@ -18,7 +18,7 @@ pub fn print_it(s: String) {
 #[doc(hidden)]
 #[cfg(not(target_family = "wasm"))]
 pub fn print_it(s: String) {
-    println!("{s}");
+    println!("wasm: {s}");
 }
 
 /// Print some data to the server log.