Merge pull request #20 from hyperware-ai/hf/try-including-parameterless-requests

nick1udwig · web-flow · commit 7e24c34d45f2 · 2025-06-30T11:21:07.000-07:00
try including parameterless requests
diff --git a/hyperprocess_macro/Cargo.toml b/hyperprocess_macro/Cargo.toml
@@ -14,8 +14,7 @@ syn = { version = "2.0", features = ["full"] }
 anyhow = "1.0"
 futures-util = "0.3"
 hyperware_app_common = { path = "../hyperware_app_common" }
-#hyperware_process_lib = { version = "1.0.4", features = ["logging"] }
-hyperware_process_lib = { git = "https://github.com/hyperware-ai/process_lib", features = ["logging"], rev = "b7c9d27" }
+hyperware_process_lib = { git = "https://github.com/hyperware-ai/process_lib", features = ["logging"], rev = "cfd6843" }
 once_cell = "1.20.2"
 paste = "1.0"
 process_macros = "0.1.0"
diff --git a/hyperprocess_macro/src/lib.rs b/hyperprocess_macro/src/lib.rs
@@ -777,7 +777,7 @@ fn generate_request_response_enums(
     // Parameter-less handlers are dispatched directly in Phase 1, not through enum deserialization
     let request_variants = function_metadata
         .iter()
-        .filter(|func| !func.params.is_empty()) // Only include handlers with parameters
+        //.filter(|func| !func.params.is_empty()) // Only include handlers with parameters
         .map(|func| {
             let variant_name = format_ident!("{}", &func.variant_name);
             generate_enum_variant(&variant_name, &func.params)
@@ -827,7 +827,7 @@ fn generate_enum_variant(
     if params.is_empty() {
         // Changed to a struct variant with no fields for functions with no parameters
         // This matches the JSON format {"VariantName": {}} sent by the client
-        quote! { #variant_name{} }
+        quote! { #variant_name }
     } else if params.len() == 1 {
         // Simple tuple variant for single parameter
         let param_type = &params[0];
@@ -923,11 +923,25 @@ fn generate_response_handling(
             quote! {
                 // Instead of wrapping in HPMResponse enum, directly serialize the result
                 let response_bytes = serde_json::to_vec(&result).unwrap();
+
+                // Get headers from APP_HELPERS if any are set
+                let headers_opt = hyperware_app_common::APP_HELPERS.with(|ctx| {
+                    let helpers = ctx.borrow();
+                    if helpers.response_headers.is_empty() {
+                        None
+                    } else {
+                        Some(helpers.response_headers.clone())
+                    }
+                });
+
                 hyperware_process_lib::http::server::send_response(
                     hyperware_process_lib::http::StatusCode::OK,
-                    None,
+                    headers_opt,
                     response_bytes
                 );
+
+                // Clear headers after sending response
+                hyperware_app_common::clear_response_headers();
             }
         }
     }
@@ -1238,10 +1252,6 @@ fn generate_message_handlers(
                         format!("Handler {} requires a request body", stringify!(#fn_name)).into_bytes()
                     );
                 }
-
-                hyperware_app_common::APP_HELPERS.with(|ctx| {
-                    ctx.borrow_mut().current_path = None;
-                });
                 return;
             }
         }
@@ -1271,28 +1281,31 @@ fn generate_message_handlers(
                     return;
                 }
             };
+
+            // Get headers from APP_HELPERS if any are set
+            let headers_opt = hyperware_app_common::APP_HELPERS.with(|ctx| {
+                let helpers = ctx.borrow();
+                if helpers.response_headers.is_empty() {
+                    None
+                } else {
+                    Some(helpers.response_headers.clone())
+                }
+            });
+
             hyperware_process_lib::http::server::send_response(
                 hyperware_process_lib::http::StatusCode::OK,
-                None,
+                headers_opt,
                 response_bytes
             );
+
+            // Clear headers after sending response
+            hyperware_app_common::clear_response_headers();
         };
 
         let handler_body = if handler.is_async {
             quote! {
-                // Capture context values before async execution
-                let current_path = hyperware_app_common::get_path();
-                let current_method = hyperware_app_common::get_http_method();
-
                 let state_ptr: *mut #self_ty = state;
                 hyperware_app_common::hyper! {
-                    // Restore context in the async task
-                    hyperware_app_common::APP_HELPERS.with(|ctx| {
-                        let mut ctx_mut = ctx.borrow_mut();
-                        ctx_mut.current_path = current_path;
-                        ctx_mut.current_http_method = current_method;
-                    });
-
                     let result = unsafe { (*state_ptr).#fn_name().await };
                     #response_handling
                 }
@@ -1312,9 +1325,6 @@ fn generate_message_handlers(
             if #path_check && #method_check {
                 hyperware_process_lib::logging::debug!("Matched parameter-less handler {} for {} {}", stringify!(#fn_name), http_method, current_path);
                 #handler_body
-                hyperware_app_common::APP_HELPERS.with(|ctx| {
-                    ctx.borrow_mut().current_path = None;
-                });
                 return;
             }
         }
@@ -1390,9 +1400,6 @@ fn generate_message_handlers(
                                                 #http_request_match_arms
                                                 hyperware_app_common::maybe_save_state(&mut *state);
                                             }
-                                            hyperware_app_common::APP_HELPERS.with(|ctx| {
-                                                ctx.borrow_mut().current_path = None;
-                                            });
                                             return;
                                         },
                                         Err(e) => {
@@ -1418,9 +1425,6 @@ fn generate_message_handlers(
                                                 None,
                                                 error_details.into_bytes()
                                             );
-                                            hyperware_app_common::APP_HELPERS.with(|ctx| {
-                                                ctx.borrow_mut().current_path = None;
-                                            });
                                             return;
                                         }
                                     }
@@ -1438,9 +1442,6 @@ fn generate_message_handlers(
                                 None,
                                 format!("No handler found for {} {}", http_method, current_path).into_bytes(),
                             );
-                            hyperware_app_common::APP_HELPERS.with(|ctx| {
-                                ctx.borrow_mut().current_path = None;
-                            });
                         },
                         hyperware_process_lib::http::server::HttpServerRequest::WebSocketPush { channel_id, message_type } => {
                             hyperware_process_lib::logging::debug!("Received WebSocket message on channel {}, type: {:?}", channel_id, message_type);
@@ -1581,7 +1582,7 @@ fn generate_component_impl(
     // Extract values from args for use in the quote macro
     let name = &args.name;
     let endpoints = &args.endpoints;
-    let _save_config = &args.save_config;
+    let save_config = &args.save_config;
     let wit_world = &args.wit_world;
 
     let icon = match &args.icon {
@@ -1655,6 +1656,11 @@ fn generate_component_impl(
                 // Initialize our state
                 let mut state = hyperware_app_common::initialize_state::<#self_ty>();
 
+                // Set to persist state according to user setting
+                hyperware_app_common::APP_CONTEXT.with(|ctx| {
+                    ctx.borrow_mut().hidden_state = Some(hyperware_app_common::HiddenState::new(#save_config));
+                });
+
                 // Set up necessary components
                 let app_name = #name;
                 let app_icon = #icon;
@@ -1691,6 +1697,11 @@ fn generate_component_impl(
                             hyperware_app_common::APP_HELPERS.with(|ctx| {
                                 ctx.borrow_mut().current_message = Some(message.clone());
                             });
+
+                            // Store old state if needed (for OnDiff save option)
+                            // This only stores if old_state is None (first time or after a save)
+                            hyperware_app_common::store_old_state(&state);
+
                             match message {
                                 hyperware_process_lib::Message::Response { body, context, .. } => {
                                     let correlation_id = context
@@ -1706,6 +1717,12 @@ fn generate_component_impl(
                                 hyperware_process_lib::Message::Request { .. } => {
                                     if message.is_local() && message.source().process == "http-server:distro:sys" {
                                         handle_http_server_message(&mut state, message);
+                                        hyperware_app_common::APP_HELPERS.with(|ctx| {
+                                            let mut ctx_mut = ctx.borrow_mut();
+                                            ctx_mut.current_path = None;
+                                            ctx_mut.current_http_method = None;
+                                            ctx_mut.response_headers = std::collections::HashMap::new();
+                                        });
                                     } else if message.is_local() {
                                         handle_local_message(&mut state, message);
                                     } else {
@@ -1773,15 +1790,15 @@ pub fn hyperprocess(attr: TokenStream, item: TokenStream) -> TokenStream {
     let http_handlers_with_params: Vec<_> = handlers
         .http
         .iter()
-        .filter(|h| !h.params.is_empty())
+        //.filter(|h| !h.params.is_empty())
         .cloned()
         .collect();
 
     // Collect all function metadata that will be represented in the HPMRequest enum.
     // This includes all local and remote handlers, plus HTTP handlers that have parameters.
     let metadata_for_enum: Vec<_> = function_metadata
         .iter()
-        .filter(|f| !f.is_http || !f.params.is_empty())
+        //.filter(|f| !f.is_http || !f.params.is_empty())
         .cloned()
         .collect();
 
diff --git a/hyperware_app_common/Cargo.toml b/hyperware_app_common/Cargo.toml
@@ -6,8 +6,7 @@ publish = false
 
 [dependencies]
 anyhow = "1.0"
-#hyperware_process_lib = { version = "1.0.4", features = ["logging"] }
-hyperware_process_lib = { git = "https://github.com/hyperware-ai/process_lib", features = ["logging"], rev = "b7c9d27" }
+hyperware_process_lib = { git = "https://github.com/hyperware-ai/process_lib", features = ["logging"], rev = "cfd6843" }
 futures-util = "0.3"
 once_cell = "1.20.2"
 paste = "1.0"
diff --git a/hyperware_app_common/src/lib.rs b/hyperware_app_common/src/lib.rs
@@ -9,7 +9,7 @@ use futures_util::task::noop_waker_ref;
 use hyperware_process_lib::http::server::HttpServer;
 use hyperware_process_lib::logging::info;
 use hyperware_process_lib::{
-    get_state, http, kiprintln, set_state, BuildError, LazyLoadBlob, Message, Request, SendError,
+    get_state, http, kiprintln, set_state, timer, BuildError, LazyLoadBlob, Message, Request, SendError,
 };
 use serde::Deserialize;
 use serde::Serialize;
@@ -38,6 +38,7 @@ thread_local! {
         current_server: None,
         current_message: None,
         current_http_method: None,
+        response_headers: HashMap::new(),
     });
 }
 
@@ -51,6 +52,7 @@ pub struct AppHelpers {
     pub current_server: Option<*mut HttpServer>,
     pub current_message: Option<Message>,
     pub current_http_method: Option<String>,
+    pub response_headers: HashMap<String, String>,
 }
 
 // Access function for the current path
@@ -67,6 +69,27 @@ pub fn get_http_method() -> Option<String> {
     APP_HELPERS.with(|ctx| ctx.borrow().current_http_method.clone())
 }
 
+// Set response headers that will be included in the HTTP response
+pub fn set_response_headers(headers: HashMap<String, String>) {
+    APP_HELPERS.with(|ctx| {
+        ctx.borrow_mut().response_headers = headers;
+    })
+}
+
+// Add a single response header
+pub fn add_response_header(key: String, value: String) {
+    APP_HELPERS.with(|ctx| {
+        ctx.borrow_mut().response_headers.insert(key, value);
+    })
+}
+
+// Clear all response headers
+pub fn clear_response_headers() {
+    APP_HELPERS.with(|ctx| {
+        ctx.borrow_mut().response_headers.clear();
+    })
+}
+
 // Access function for the source address of the current message
 pub fn source() -> hyperware_process_lib::Address {
     APP_HELPERS.with(|ctx| {
@@ -163,6 +186,21 @@ pub enum AppSendError {
     BuildError(BuildError),
 }
 
+pub async fn sleep(sleep_ms: u64) -> Result<(), AppSendError> {
+    let request = Request::to(("our", "timer", "distro", "sys"))
+        .body(timer::TimerAction::SetTimer(sleep_ms))
+        .expects_response((sleep_ms / 1_000) + 1);
+
+    let correlation_id = Uuid::new_v4().to_string();
+    if let Err(e) = request.context(correlation_id.as_bytes().to_vec()).send() {
+        return Err(AppSendError::BuildError(e));
+    }
+
+    let _ = ResponseFuture::new(correlation_id).await;
+
+    return Ok(());
+}
+
 pub async fn send<R>(request: Request) -> Result<R, AppSendError>
 where
     R: serde::de::DeserializeOwned,
@@ -235,17 +273,21 @@ pub enum SaveOptions {
     EveryNMessage(u64),
     // Persist State Every N Seconds
     EveryNSeconds(u64),
+    // Persist State Only If Changed
+    OnDiff,
 }
 pub struct HiddenState {
     save_config: SaveOptions,
     message_count: u64,
+    old_state: Option<Vec<u8>>, // Stores the serialized state from before message processing
 }
 
 impl HiddenState {
     pub fn new(save_config: SaveOptions) -> Self {
         Self {
             save_config,
             message_count: 0,
+            old_state: None,
         }
     }
 
@@ -263,12 +305,32 @@ impl HiddenState {
                 }
             }
             SaveOptions::EveryNSeconds(_) => false, // Handled by timer instead
+            SaveOptions::OnDiff => false, // Will be handled separately with state comparison
         }
     }
 }
 
 // TODO: We need a timer macro again.
 
+/// Store a snapshot of the current state before processing a message
+/// This is used for OnDiff save option to compare state before and after
+/// Only stores if old_state is None (i.e., first time or after a save)
+pub fn store_old_state<S>(state: &S)
+where
+    S: serde::Serialize,
+{
+    APP_CONTEXT.with(|ctx| {
+        let mut ctx_mut = ctx.borrow_mut();
+        if let Some(ref mut hidden_state) = ctx_mut.hidden_state {
+            if matches!(hidden_state.save_config, SaveOptions::OnDiff) && hidden_state.old_state.is_none() {
+                if let Ok(s_bytes) = rmp_serde::to_vec(state) {
+                    hidden_state.old_state = Some(s_bytes);
+                }
+            }
+        }
+    });
+}
+
 /// Trait that must be implemented by application state types
 pub trait State {
     /// Creates a new instance of the state.
@@ -416,10 +478,35 @@ where
     APP_CONTEXT.with(|ctx| {
         let mut ctx_mut = ctx.borrow_mut();
         if let Some(ref mut hidden_state) = ctx_mut.hidden_state {
-            if hidden_state.should_save_state() {
+            let should_save = if matches!(hidden_state.save_config, SaveOptions::OnDiff) {
+                // For OnDiff, compare current state with old state
+                if let Ok(current_bytes) = rmp_serde::to_vec(state) {
+                    let state_changed = match &hidden_state.old_state {
+                        Some(old_bytes) => old_bytes != &current_bytes,
+                        None => true, // If no old state, consider it changed
+                    };
+
+                    if state_changed {
+                        true
+                    } else {
+                        false
+                    }
+                } else {
+                    false
+                }
+            } else {
+                hidden_state.should_save_state()
+            };
+
+            if should_save {
                 if let Ok(s_bytes) = rmp_serde::to_vec(state) {
                     kiprintln!("State persisted");
                     let _ = set_state(&s_bytes);
+
+                    // Clear old_state after saving so it can be set again on next message
+                    if matches!(hidden_state.save_config, SaveOptions::OnDiff) {
+                        hidden_state.old_state = None;
+                    }
                 }
             }
         }
