Merge pull request #269 from obeli-sk/feat/activity-js-custom-params

feat(activity-js): Support custom parameters in JS activities

Author: tomasol

crates/activity-js-runtime/src/activity_js_runtime.rs

@@ -21,12 +21,12 @@ use std::rc::Rc;
 
 /// Execute JavaScript code with the given parameters.
 ///
-/// `params_json` is expected to be a JSON array string. The array is passed
-/// as the first and only argument to `fn_name`.
+/// `params_json` is a list of JSON-serialized parameter values.
+/// Each element is passed as a positional argument to the JS function `fn_name`.
 pub fn execute(
     fn_name: &str,
     js_code: &str,
-    params_json: &str,
+    params_json: &[String],
 ) -> Result<Result<String, String>, JsRuntimeError> {
     // `fn_name` comes from trusted `activity_js_worker`, must be FFQN's fn name
     let fn_name = fn_name.replace('-', "_");
@@ -44,12 +44,16 @@ pub fn execute(
     setup_fetch(&mut context).expect("fetch setup must work");
 
     // `params_json` is sent by trusted `activity_js_worker`, params were typechecked.
-    // Store as global `__params__` array.
-    // Direct interpolation,  JSON array/object literals are valid JavaScript syntax.
-    let params_code = format!("const __params__ = {params_json};");
+    // Parse each JSON param and store as `__params__` array.
+    let mut params_js_parts = Vec::with_capacity(params_json.len());
+    for param in params_json {
+        // Each param is a JSON value — valid JavaScript literal syntax.
+        params_js_parts.push(param.as_str());
+    }
+    let params_array = format!("const __params__ = [{}];", params_js_parts.join(", "));
     context
-        .eval(Source::from_bytes(&params_code))
-        .expect("already verified that params_json is parseable");
+        .eval(Source::from_bytes(&params_array))
+        .expect("already verified that params_json elements are parseable");
 
     // Add the function to the context, without running it.
     let bare_fn_eval = context.eval(Source::from_bytes(js_code));
@@ -69,7 +73,11 @@ pub fn execute(
         return Err(JsRuntimeError::FunctionNotFound);
     }
 
-    let call_fn = format!("{fn_name}(__params__);");
+    // Spread params as positional arguments: fn_name(__params__[0], __params__[1], ...)
+    let spread_args: Vec<String> = (0..params_json.len())
+        .map(|i| format!("__params__[{i}]"))
+        .collect();
+    let call_fn = format!("{fn_name}({});", spread_args.join(", "));
 
     let result = context.eval(Source::from_bytes(&call_fn));
 

crates/activity-js-runtime/src/lib.rs

@@ -17,7 +17,7 @@ impl Guest for Component {
     fn run(
         fn_name: String,
         js_code: String,
-        params_json: String,
+        params_json: Vec<String>,
     ) -> Result<Result<String, String>, JsRuntimeError> {
         activity_js_runtime::execute(&fn_name, &js_code, &params_json)
     }

crates/activity-js-runtime/wit/obelisk_js-runtime/execute.wit

@@ -17,9 +17,10 @@ interface execute {
     /// Execute JavaScript code as an activity.
     ///
     /// The JS code should define a function named as declared in `fn-name` that receives
-    /// the params as positional arguments (spread from the JSON array)
-    /// and returns a JSON-serializable value.
+    /// the params as positional arguments (each element is one JSON-serialized parameter value)
+    /// and returns a string.
     ///
-    /// Returns Ok(json_result) on success, Err(error_message) on failure.
-    run: func(fn-name: string, js-code: string, params-json: string) -> result<result<string, string>, js-runtime-error>;
+    /// Returns Ok(Ok(string)) on success, Ok(Err(string)) on thrown string/Error,
+    /// or Err(js-runtime-error) on type/declaration errors.
+    run: func(fn-name: string, js-code: string, params-json: list<string>) -> result<result<string, string>, js-runtime-error>;
 }

crates/testing/test-programs/js/activity/fetch.js

@@ -1,6 +1,6 @@
-async function fetch_get(params) {
-    console.info("Fetching " + params[0]);
-    const resp = await fetch(params[0]);
+async function fetch_get(url) {
+    console.info("Fetching " + url);
+    const resp = await fetch(url);
     const text = await resp.text();
     return text;
 }

crates/val-json/src/type_wrapper.rs

@@ -452,3 +452,233 @@ mod tests {
         );
     }
 }
+
+/// Parse a WIT type syntax string into a `TypeWrapper`.
+///
+/// Supports primitives (`bool`, `u8`..`u64`, `s8`..`s64`, `f32`, `f64`, `char`, `string`),
+/// `list<T>`, `option<T>`, `tuple<T1, T2, ...>`, and `result` variants.
+pub fn parse_wit_type(s: &str) -> Result<TypeWrapper, String> {
+    let s = s.trim();
+    let (ty, rest) = parse_type(s)?;
+    let rest = rest.trim();
+    if !rest.is_empty() {
+        return Err(format!("unexpected trailing characters: '{rest}'"));
+    }
+    Ok(ty)
+}
+
+fn parse_type(s: &str) -> Result<(TypeWrapper, &str), String> {
+    let s = s.trim();
+    if s.is_empty() {
+        return Err("unexpected end of input".to_string());
+    }
+
+    let ident_end = s
+        .find(|c: char| !c.is_ascii_alphanumeric() && c != '-' && c != '_')
+        .unwrap_or(s.len());
+    let ident = &s[..ident_end];
+    let rest = &s[ident_end..];
+
+    match ident {
+        "bool" => Ok((TypeWrapper::Bool, rest)),
+        "s8" => Ok((TypeWrapper::S8, rest)),
+        "u8" => Ok((TypeWrapper::U8, rest)),
+        "s16" => Ok((TypeWrapper::S16, rest)),
+        "u16" => Ok((TypeWrapper::U16, rest)),
+        "s32" => Ok((TypeWrapper::S32, rest)),
+        "u32" => Ok((TypeWrapper::U32, rest)),
+        "s64" => Ok((TypeWrapper::S64, rest)),
+        "u64" => Ok((TypeWrapper::U64, rest)),
+        "f32" => Ok((TypeWrapper::F32, rest)),
+        "f64" => Ok((TypeWrapper::F64, rest)),
+        "char" => Ok((TypeWrapper::Char, rest)),
+        "string" => Ok((TypeWrapper::String, rest)),
+
+        "list" => {
+            let rest = expect_char(rest.trim_start(), '<')?;
+            let (inner, rest) = parse_type(rest)?;
+            let rest = expect_char(rest.trim_start(), '>')?;
+            Ok((TypeWrapper::List(Box::new(inner)), rest))
+        }
+
+        "option" => {
+            let rest = expect_char(rest.trim_start(), '<')?;
+            let (inner, rest) = parse_type(rest)?;
+            let rest = expect_char(rest.trim_start(), '>')?;
+            Ok((TypeWrapper::Option(Box::new(inner)), rest))
+        }
+
+        "tuple" => {
+            let rest = expect_char(rest.trim_start(), '<')?;
+            let (items, rest) = parse_comma_separated_types(rest, '>')?;
+            Ok((TypeWrapper::Tuple(items.into_boxed_slice()), rest))
+        }
+
+        "result" => {
+            let rest_trimmed = rest.trim_start();
+            if !rest_trimmed.starts_with('<') {
+                return Ok((
+                    TypeWrapper::Result {
+                        ok: None,
+                        err: None,
+                    },
+                    rest,
+                ));
+            }
+            let rest = expect_char(rest_trimmed, '<')?;
+            let rest_trimmed = rest.trim_start();
+
+            let (ok, rest) = if let Some(stripped) = rest_trimmed.strip_prefix('_') {
+                (None, stripped)
+            } else {
+                let (ty, rest) = parse_type(rest)?;
+                (Some(Box::new(ty)), rest)
+            };
+
+            let rest_trimmed = rest.trim_start();
+
+            if let Some(rest) = rest_trimmed.strip_prefix(',') {
+                let (err_ty, rest) = parse_type(rest)?;
+                let rest = expect_char(rest.trim_start(), '>')?;
+                Ok((
+                    TypeWrapper::Result {
+                        ok,
+                        err: Some(Box::new(err_ty)),
+                    },
+                    rest,
+                ))
+            } else {
+                let rest = expect_char(rest_trimmed, '>')?;
+                Ok((TypeWrapper::Result { ok, err: None }, rest))
+            }
+        }
+
+        _ => Err(format!("unknown type: '{ident}'")),
+    }
+}
+
+fn expect_char(s: &str, expected: char) -> Result<&str, String> {
+    let s = s.trim_start();
+    if s.starts_with(expected) {
+        Ok(&s[expected.len_utf8()..])
+    } else {
+        let found = s
+            .chars()
+            .next()
+            .map_or("end of input".to_string(), |c| format!("'{c}'"));
+        Err(format!("expected '{expected}', found {found}"))
+    }
+}
+
+fn parse_comma_separated_types(s: &str, closing: char) -> Result<(Vec<TypeWrapper>, &str), String> {
+    let mut items = Vec::new();
+    let mut rest = s.trim_start();
+
+    if rest.starts_with(closing) {
+        return Ok((items, &rest[closing.len_utf8()..]));
+    }
+
+    loop {
+        let (ty, r) = parse_type(rest)?;
+        items.push(ty);
+        rest = r.trim_start();
+
+        if rest.starts_with(',') {
+            rest = rest[1..].trim_start();
+        } else if rest.starts_with(closing) {
+            rest = &rest[closing.len_utf8()..];
+            break;
+        } else {
+            let found = rest
+                .chars()
+                .next()
+                .map_or("end of input".to_string(), |c| format!("'{c}'"));
+            return Err(format!("expected ',' or '{closing}', found {found}"));
+        }
+    }
+
+    Ok((items, rest))
+}
+
+#[cfg(test)]
+mod tests_parse_wit_type {
+    use super::*;
+
+    #[test]
+    fn primitives() {
+        assert_eq!(parse_wit_type("bool").unwrap(), TypeWrapper::Bool);
+        assert_eq!(parse_wit_type("u32").unwrap(), TypeWrapper::U32);
+        assert_eq!(parse_wit_type("string").unwrap(), TypeWrapper::String);
+        assert_eq!(parse_wit_type("f64").unwrap(), TypeWrapper::F64);
+    }
+
+    #[test]
+    fn list() {
+        assert_eq!(
+            parse_wit_type("list<string>").unwrap(),
+            TypeWrapper::List(Box::new(TypeWrapper::String))
+        );
+        assert_eq!(
+            parse_wit_type("list<list<u8>>").unwrap(),
+            TypeWrapper::List(Box::new(TypeWrapper::List(Box::new(TypeWrapper::U8))))
+        );
+    }
+
+    #[test]
+    fn option() {
+        assert_eq!(
+            parse_wit_type("option<u32>").unwrap(),
+            TypeWrapper::Option(Box::new(TypeWrapper::U32))
+        );
+    }
+
+    #[test]
+    fn tuple() {
+        assert_eq!(
+            parse_wit_type("tuple<u32, string>").unwrap(),
+            TypeWrapper::Tuple(vec![TypeWrapper::U32, TypeWrapper::String].into_boxed_slice())
+        );
+    }
+
+    #[test]
+    fn result_variants() {
+        assert_eq!(
+            parse_wit_type("result<string, string>").unwrap(),
+            TypeWrapper::Result {
+                ok: Some(Box::new(TypeWrapper::String)),
+                err: Some(Box::new(TypeWrapper::String)),
+            }
+        );
+        assert_eq!(
+            parse_wit_type("result<string>").unwrap(),
+            TypeWrapper::Result {
+                ok: Some(Box::new(TypeWrapper::String)),
+                err: None,
+            }
+        );
+        assert_eq!(
+            parse_wit_type("result").unwrap(),
+            TypeWrapper::Result {
+                ok: None,
+                err: None,
+            }
+        );
+        assert_eq!(
+            parse_wit_type("result<_, string>").unwrap(),
+            TypeWrapper::Result {
+                ok: None,
+                err: Some(Box::new(TypeWrapper::String)),
+            }
+        );
+    }
+
+    #[test]
+    fn trailing_chars() {
+        assert!(parse_wit_type("u32 extra").is_err());
+    }
+
+    #[test]
+    fn unknown_type() {
+        assert!(parse_wit_type("foobar").is_err());
+    }
+}