new sqlpage.link function

Author: lovasoa

CHANGELOG.md

@@ -27,6 +27,14 @@
  - Updated apexcharts.js to [v3.50.0](https://github.com/apexcharts/apexcharts.js/releases/tag/v3.50.0)
  - Improve truncation of long page titles
    - ![screenshot long title](https://github.com/lovasoa/SQLpage/assets/552629/9859023e-c706-47b3-aa9e-1c613046fdfa)
+ - new function: [`sqlpage.link`](https://sql.ophir.dev/functions.sql?function=link#function) to easily create links with parameters between pages. For instance, you can now use
+      ```sql
+      select 'list' as component;
+      select
+        product_name as title,
+        sqlpage.link('product.sql', json_object('product_id', product_id)) as link
+      from products;
+      ```
 
 ## 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/sqlpage_functions/functions.rs

@@ -1,6 +1,10 @@
 use super::RequestInfo;
 use crate::webserver::{
-    database::execute_queries::DbConn, http::SingleOrVec, request_variables::ParamMap,
+    database::{
+        execute_queries::DbConn, sqlpage_functions::url_parameter_deserializer::URLParameters,
+    },
+    http::SingleOrVec,
+    request_variables::ParamMap,
     ErrorWithStatus,
 };
 use anyhow::{anyhow, Context};
@@ -23,6 +27,8 @@ super::function_definition_macro::sqlpage_functions! {
     hash_password(password: Option<String>);
     header((&RequestInfo), name: Cow<str>);
 
+    link(file: Cow<str>, parameters: Cow<str>);
+
     path((&RequestInfo));
     persist_uploaded_file((&RequestInfo), field_name: Cow<str>, folder: Option<Cow<str>>, allowed_extensions: Option<Cow<str>>);
     protocol((&RequestInfo));
@@ -188,6 +194,19 @@ async fn header<'a>(request: &'a RequestInfo, name: Cow<'a, str>) -> Option<Cow<
     request.headers.get(&*name).map(SingleOrVec::as_json_str)
 }
 
+/// Builds a URL from a file name and a JSON object conatining URL parameters.
+/// For instance, if the file is "index.sql" and the parameters are {"x": "hello world"},
+/// the result will be "index.sql?x=hello%20world".
+async fn link<'a>(file: Cow<'a, str>, parameters: Option<Cow<'a, str>>) -> anyhow::Result<String> {
+    let mut url = file.into_owned();
+    if let Some(parameters) = parameters {
+        url.push('?');
+        let encoded = serde_json::from_str::<URLParameters>(&parameters)?;
+        url.push_str(encoded.get());
+    }
+    Ok(url)
+}
+
 /// Returns the path component of the URL of the current request.
 async fn path(request: &RequestInfo) -> &str {
     &request.path

src/webserver/database/sqlpage_functions/mod.rs

@@ -2,6 +2,7 @@ mod function_definition_macro;
 mod function_traits;
 pub(super) mod functions;
 mod http_fetch_request;
+mod url_parameter_deserializer;
 
 use sqlparser::ast::FunctionArg;
 

src/webserver/database/sqlpage_functions/url_parameter_deserializer.rs

@@ -0,0 +1,91 @@
+use percent_encoding::{percent_encode, NON_ALPHANUMERIC};
+use serde::{Deserialize, Deserializer};
+use std::borrow::Cow;
+use std::fmt;
+
+pub struct URLParameters(String);
+
+impl URLParameters {
+    fn encode_and_push(&mut self, v: &str) {
+        let val: Cow<str> = percent_encode(v.as_bytes(), NON_ALPHANUMERIC).into();
+        self.0.push_str(&val);
+    }
+    fn push_kv(&mut self, key: &str, value: &str) {
+        if !self.0.is_empty() {
+            self.0.push('&');
+        }
+        self.encode_and_push(key);
+        self.0.push('=');
+        self.encode_and_push(value);
+    }
+    pub fn get(&self) -> &str {
+        &self.0
+    }
+}
+
+impl<'de> Deserialize<'de> for URLParameters {
+    fn deserialize<D>(deserializer: D) -> Result<URLParameters, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Visit an object and append keys and values to the string
+        struct URLParametersVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for URLParametersVisitor {
+            type Value = URLParameters;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a sequence")
+            }
+
+            fn visit_map<A>(self, mut map: A) -> Result<URLParameters, A::Error>
+            where
+                A: serde::de::MapAccess<'de>,
+            {
+                let mut out = URLParameters(String::new());
+                while let Some((key, value)) =
+                    map.next_entry::<Cow<str>, Cow<serde_json::value::RawValue>>()?
+                {
+                    let value = value.get();
+                    if let Ok(str_val) = serde_json::from_str::<Cow<str>>(value) {
+                        out.push_kv(&key, &str_val);
+                    } else if let Ok(vec_val) =
+                        serde_json::from_str::<Vec<serde_json::Value>>(value)
+                    {
+                        for val in vec_val {
+                            if !out.0.is_empty() {
+                                out.0.push('&');
+                            }
+                            out.encode_and_push(&key);
+                            out.0.push_str("[]");
+                            out.0.push('=');
+                            out.encode_and_push(&val.to_string());
+                        }
+                    } else {
+                        out.push_kv(&key, value);
+                    }
+                }
+
+                Ok(out)
+            }
+        }
+
+        deserializer.deserialize_map(URLParametersVisitor)
+    }
+}
+
+#[test]
+fn test_url_parameters_deserializer() {
+    use serde_json::json;
+    let json = json!({
+        "x": "hello world",
+        "num": 123,
+        "arr": [1, 2, 3],
+    });
+
+    let url_parameters: URLParameters = serde_json::from_value(json).unwrap();
+    assert_eq!(
+        url_parameters.0,
+        "x=hello%20world&num=123&arr[]=1&arr[]=2&arr[]=3"
+    );
+}