Call route: when caller sends BSATN, respond in kind.

Author: gefjon

crates/client-api/src/routes/database.rs

@@ -142,7 +142,7 @@ pub async fn call<S: ControlStateDelegate + NodeDelegate>(
 ) -> axum::response::Result<impl IntoResponse> {
     let caller_identity = auth.claims.identity;
 
-    let args = parse_call_args(content_type, body)?;
+    let (args, want_bsatn) = parse_call_args(content_type, body)?;
 
     // HTTP callers always need a connection ID to provide to connect/disconnect,
     // so generate one.
@@ -195,8 +195,14 @@ pub async fn call<S: ControlStateDelegate + NodeDelegate>(
 
     match result {
         Ok(CallResult::Reducer(result)) => {
-            let (status, body) =
-                reducer_outcome_response(&module, &owner_identity, &reducer, result.outcome, reducer_return_value)?;
+            let (status, body) = reducer_outcome_response(
+                &module,
+                &owner_identity,
+                &reducer,
+                result.outcome,
+                reducer_return_value,
+                want_bsatn,
+            )?;
             Ok((
                 status,
                 TypedHeader(SpacetimeEnergyUsed(result.energy_used)),
@@ -209,7 +215,7 @@ pub async fn call<S: ControlStateDelegate + NodeDelegate>(
             // Procedures don't assign a special meaning to error returns, unlike reducers,
             // as there's no transaction for them to automatically abort.
             // Instead, we just pass on their return value with the OK status so long as we successfully invoked the procedure.
-            let (status, body) = procedure_outcome_response(result.return_val);
+            let (status, body) = procedure_outcome_response(result.return_val, want_bsatn);
             Ok((
                 status,
                 TypedHeader(SpacetimeExecutionDurationMicros(result.execution_duration)),
@@ -225,13 +231,15 @@ pub async fn call<S: ControlStateDelegate + NodeDelegate>(
 ///
 /// - `application/json` → [`FunctionArgs::Json`] (UTF-8 required).
 /// - `application/octet-stream` → [`FunctionArgs::Bsatn`] (raw BSATN bytes).
-fn parse_call_args(content_type: headers::ContentType, body: Bytes) -> axum::response::Result<FunctionArgs> {
+///
+/// Also returns `want_bsatn`, a bool, which is true if and only if the response should be BSATN-encoded.
+fn parse_call_args(content_type: headers::ContentType, body: Bytes) -> axum::response::Result<(FunctionArgs, bool)> {
     if content_type == headers::ContentType::json() {
         let s = bytestring::ByteString::try_from(body)
             .map_err(|_| (StatusCode::BAD_REQUEST, "request body is not valid UTF-8").into_response())?;
-        Ok(FunctionArgs::Json(s))
+        Ok((FunctionArgs::Json(s), false))
     } else if content_type == headers::ContentType::octet_stream() {
-        Ok(FunctionArgs::Bsatn(body))
+        Ok((FunctionArgs::Bsatn(body), true))
     } else {
         Err((
             StatusCode::BAD_REQUEST,
@@ -241,12 +249,18 @@ fn parse_call_args(content_type: headers::ContentType, body: Bytes) -> axum::res
     }
 }
 
+/// Encode a reducer return value as an HTTP response.
+///
+/// If the outcome is an error, return a raw string with `application/text`. Ignore `want_bsatn` in this case.
+/// If the outcome is successful, and `want_bsatn`, send BSATN with `application/octet-stream`.
+/// If the outcome is successful, and not `want_bsatn`, send JSON with `application/json`.
 fn reducer_outcome_response(
     module: &ModuleHost,
     owner_identity: &Identity,
     reducer: &str,
     outcome: ReducerOutcome,
     reducer_return_value: Option<Bytes>,
+    want_bsatn: bool,
 ) -> axum::response::Result<(StatusCode, axum::response::Response)> {
     match outcome {
         ReducerOutcome::Committed => {
@@ -258,20 +272,29 @@ fn reducer_outcome_response(
             };
 
             if let Some(bytes) = reducer_return_value.filter(|value| !value.is_empty()) {
-                let seed = sats::WithTypespace::new(module.info.module_def.typespace(), &return_value);
-                let mut reader = &bytes[..];
-                let value: AlgebraicValue = seed.deserialize(bsatn::Deserializer::new(&mut reader)).map_err(|err| {
-                    (
-                        StatusCode::INTERNAL_SERVER_ERROR,
-                        format!("Failed to decode reducer return value: {err}"),
-                    )
-                })?;
-                Ok((
-                    StatusCode::OK,
-                    axum::Json(sats::serde::SerdeWrapper(value)).into_response(),
-                ))
+                if want_bsatn {
+                    Ok((StatusCode::OK, bytes.into_response()))
+                } else {
+                    let seed = sats::WithTypespace::new(module.info.module_def.typespace(), &return_value);
+                    let mut reader = &bytes[..];
+                    let value: AlgebraicValue =
+                        seed.deserialize(bsatn::Deserializer::new(&mut reader)).map_err(|err| {
+                            (
+                                StatusCode::INTERNAL_SERVER_ERROR,
+                                format!("Failed to decode reducer return value: {err}"),
+                            )
+                        })?;
+                    Ok((
+                        StatusCode::OK,
+                        axum::Json(sats::serde::SerdeWrapper(value)).into_response(),
+                    ))
+                }
             } else {
-                Ok((StatusCode::OK, "".into_response()))
+                if want_bsatn {
+                    Ok((StatusCode::OK, Vec::<u8>::new().into_response()))
+                } else {
+                    Ok((StatusCode::OK, "".into_response()))
+                }
             }
         }
         ReducerOutcome::Failed(errmsg) => {
@@ -354,10 +377,20 @@ pub enum DBCallErr {
     InstanceNotScheduled,
 }
 
-fn procedure_outcome_response(return_val: AlgebraicValue) -> (StatusCode, axum::response::Response) {
+/// Encode a procedure's result as an HTTP response.
+///
+/// If `want_bsatn`, send BSATN bytes as `application/octet-stream`.
+/// If not `want_bsatn`, send JSON as `application/json`.
+fn procedure_outcome_response(return_val: AlgebraicValue, want_bsatn: bool) -> (StatusCode, axum::response::Response) {
     (
         StatusCode::OK,
-        axum::Json(sats::serde::SerdeWrapper(return_val)).into_response(),
+        if want_bsatn {
+            bsatn::to_vec(&return_val)
+                .expect("BSATN serializing an AlgebraicValue should be infallible")
+                .into_response()
+        } else {
+            axum::Json(sats::serde::SerdeWrapper(return_val)).into_response()
+        },
     )
 }