calls to json_object in sqlpage function arguments

Author: lovasoa

CHANGELOG.md

@@ -36,6 +36,7 @@
       from products;
       ```
     - Before, you would usually build the link manually with `CONCAT('/product.sql?product=', product_name)`, which would fail if the product name contained special characters like '&'. The new `sqlpage.link` function takes care of encoding the parameters correctly.
+ - Calls to `json_object` are now accepted as arguments to SQLPage functions. This allows you to pass complex data structures to functions such as `sqlpage.fetch`, `sqlpage.run_sql`, and `sqlpage.link`. 
 
 ## 0.24.0 (2024-06-23)
  - in the form component, searchable `select` fields now support more than 50 options. They used to display only the first 50 options. 

src/webserver/database/sql.rs

@@ -587,14 +587,24 @@ fn expr_to_stmt_param(arg: &mut Expr) -> Option<StmtParam> {
                     ..
                 }),
             ..
-        }) if func_name_parts.len() == 1
-            && func_name_parts[0].value.eq_ignore_ascii_case("concat") =>
-        {
-            let mut concat_args = Vec::with_capacity(args.len());
-            for arg in args {
-                concat_args.push(function_arg_to_stmt_param(arg)?);
+        }) if func_name_parts.len() == 1 => {
+            let func_name = func_name_parts[0].value.as_str();
+            if func_name.eq_ignore_ascii_case("concat") {
+                let mut concat_args = Vec::with_capacity(args.len());
+                for arg in args {
+                    concat_args.push(function_arg_to_stmt_param(arg)?);
+                }
+                Some(StmtParam::Concat(concat_args))
+            } else if func_name.eq_ignore_ascii_case("json_object") {
+                let mut json_obj_args = Vec::with_capacity(args.len());
+                for arg in args {
+                    json_obj_args.push(function_arg_to_stmt_param(arg)?);
+                }
+                Some(StmtParam::JsonObject(json_obj_args))
+            } else {
+                log::warn!("SQLPage cannot emulate the following function: {func_name}");
+                None
             }
-            Some(StmtParam::Concat(concat_args))
         }
         _ => {
             log::warn!("Unsupported function argument: {arg}");

src/webserver/database/syntax_tree.rs

@@ -38,6 +38,7 @@ pub(crate) enum StmtParam {
     Literal(String),
     Null,
     Concat(Vec<StmtParam>),
+    JsonObject(Vec<StmtParam>),
     FunctionCall(SqlPageFunctionCall),
 }
 
@@ -56,6 +57,13 @@ impl std::fmt::Display for StmtParam {
                 }
                 write!(f, ")")
             }
+            StmtParam::JsonObject(items) => {
+                write!(f, "JSON_OBJECT(")?;
+                for item in items {
+                    write!(f, "{item}, ")?;
+                }
+                write!(f, ")")
+            }
             StmtParam::FunctionCall(call) => write!(f, "{call}"),
             StmtParam::Error(x) => {
                 if let Some((i, _)) = x.char_indices().nth(21) {
@@ -145,6 +153,7 @@ pub(super) async fn extract_req_param<'a, 'b>(
         StmtParam::Literal(x) => Some(Cow::Owned(x.to_string())),
         StmtParam::Null => None,
         StmtParam::Concat(args) => concat_params(&args[..], request, db_connection).await?,
+        StmtParam::JsonObject(args) => json_object_params(&args[..], request, db_connection).await?,
         StmtParam::FunctionCall(func) => func.evaluate(request, db_connection).await.with_context(|| {
             format!(
                 "Error in function call {func}.\nExpected {:#}",
@@ -168,3 +177,26 @@ async fn concat_params<'a, 'b>(
     }
     Ok(Some(Cow::Owned(result)))
 }
+
+async fn json_object_params<'a, 'b>(
+    args: &[StmtParam],
+    request: &'a RequestInfo,
+    db_connection: &'b mut DbConn,
+) -> anyhow::Result<Option<Cow<'a, str>>> {
+    use serde::{ser::SerializeMap, Serializer};
+    let mut result = Vec::new();
+    let mut ser = serde_json::Serializer::new(&mut result);
+    let mut map_ser = ser.serialize_map(Some(args.len()))?;
+    let mut it = args.iter();
+    while let Some(key) = it.next() {
+        let key = Box::pin(extract_req_param(key, request, db_connection)).await?;
+        map_ser.serialize_key(&key)?;
+        let val = it
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("Odd number of arguments in JSON_OBJECT"))?;
+        let val = Box::pin(extract_req_param(val, request, db_connection)).await?;
+        map_ser.serialize_value(&val)?;
+    }
+    map_ser.end()?;
+    Ok(Some(Cow::Owned(String::from_utf8(result)?)))
+}

tests/sql_test_files/it_works_link.sql

@@ -0,0 +1,5 @@
+select 'text' as component, 
+    case sqlpage.link('test.sql', json_object('x', 123))
+        when 'test.sql?x=123' then 'It works !'
+        else 'error: ' || coalesce(sqlpage.link('test.sql', json_object('x', 123)), 'NULL')
+    end AS contents;

tests/sql_test_files/it_works_run_sql_from_database.sql

@@ -1,5 +1,5 @@
 select 'dynamic' as component,
-    sqlpage.run_sql('tests/display_text.sql', CONCAT('{"html": "', html,'"}')) as properties
+    sqlpage.run_sql('tests/display_text.sql', json_object('html', html)) as properties
 from (
     select 'It ' as html
     union all