[WIP] Encryption for secure values (#183)

src-tauri/yaak-templates/src/error.rs

@@ -1,5 +1,6 @@
 use serde::{Serialize, Serializer};
 use thiserror::Error;
+use wasm_bindgen::JsValue;
 
 #[derive(Error, Debug, PartialEq)]
 pub enum Error {
@@ -22,4 +23,10 @@ impl Serialize for Error {
     }
 }
 
+impl Into<JsValue> for Error {
+    fn into(self) -> JsValue {
+        serde_wasm_bindgen::to_value(&self).unwrap()
+    }
+}
+
 pub type Result<T> = std::result::Result<T, Error>;

src-tauri/yaak-templates/src/lib.rs

@@ -2,6 +2,7 @@ pub mod format;
 pub mod parser;
 pub mod renderer;
 pub mod error;
+pub mod wasm;
 
 pub use parser::*;
 pub use renderer::*;

src-tauri/yaak-templates/src/parser.rs

@@ -1,12 +1,13 @@
+use crate::TemplateCallback;
 use crate::error::Error::RenderError;
 use crate::error::Result;
-use base64::prelude::BASE64_URL_SAFE_NO_PAD;
 use base64::Engine;
+use base64::prelude::BASE64_URL_SAFE_NO_PAD;
 use serde::{Deserialize, Serialize};
 use std::fmt::Display;
 use ts_rs::TS;
 
-#[derive(Clone, PartialEq, Debug, Serialize, Deserialize, TS)]
+#[derive(Default, Clone, PartialEq, Debug, Serialize, Deserialize, TS)]
 #[ts(export, export_to = "parser.ts")]
 pub struct Tokens {
     pub tokens: Vec<Token>,
@@ -94,6 +95,53 @@ impl Display for Token {
     }
 }
 
+fn transform_val<T: TemplateCallback>(val: &Val, cb: &T) -> Result<Val> {
+    let val = match val {
+        Val::Fn {
+            name: fn_name,
+            args,
+        } => {
+            let mut new_args: Vec<FnArg> = Vec::new();
+            for arg in args {
+                let value = match arg.clone().value {
+                    Val::Str { text } => {
+                        let text = cb.transform_arg(&fn_name, &arg.name, &text)?;
+                        Val::Str { text }
+                    }
+                    v => transform_val(&v, cb)?,
+                };
+
+                let arg_name = arg.name.clone();
+                new_args.push(FnArg {
+                    name: arg_name,
+                    value,
+                });
+            }
+            Val::Fn {
+                name: fn_name.clone(),
+                args: new_args,
+            }
+        }
+        _ => val.clone(),
+    };
+    Ok(val)
+}
+
+pub fn transform_args<T: TemplateCallback>(tokens: Tokens, cb: &T) -> Result<Tokens> {
+    let mut new_tokens = Tokens::default();
+    for t in tokens.tokens.iter() {
+        new_tokens.tokens.push(match t {
+            Token::Tag { val } => {
+                let val = transform_val(val, cb)?;
+                Token::Tag { val }
+            }
+            _ => t.clone(),
+        });
+    }
+
+    Ok(new_tokens)
+}
+
 // Template Syntax
 //
 //  ${[ my_var ]}
@@ -438,8 +486,8 @@ impl Parser {
 
 #[cfg(test)]
 mod tests {
-    use crate::error::Result;
     use crate::Val::Null;
+    use crate::error::Result;
     use crate::*;
 
     #[test]

src-tauri/yaak-templates/src/renderer.rs

@@ -13,6 +13,8 @@ pub trait TemplateCallback {
         fn_name: &str,
         args: HashMap<String, String>,
     ) -> impl Future<Output = Result<String>> + Send;
+
+    fn transform_arg(&self, fn_name: &str, arg_name: &str, arg_value: &str) -> Result<String>;
 }
 
 pub async fn render_json_value_raw<T: TemplateCallback>(
@@ -104,16 +106,16 @@ async fn render_value<T: TemplateCallback>(
             }
             None => return Err(VariableNotFound(name)),
         },
-        Val::Bool { value } => value.to_string(),
         Val::Fn { name, args } => {
-            // let empty = "".to_string();
             let mut resolved_args: HashMap<String, String> = HashMap::new();
             for a in args {
                 let v = Box::pin(render_value(a.value, vars, cb, depth)).await?;
                 resolved_args.insert(a.name, v);
             }
-            cb.run(name.as_str(), resolved_args.clone()).await?
+            let result = cb.run(name.as_str(), resolved_args.clone()).await?;
+            Box::pin(parse_and_render_at_depth(&result, vars, cb, depth)).await?
         }
+        Val::Bool { value } => value.to_string(),
         Val::Null => "".into(),
     };
 
@@ -134,6 +136,15 @@ mod parse_and_render_tests {
         async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
             todo!()
         }
+
+        fn transform_arg(
+            &self,
+            _fn_name: &str,
+            _arg_name: &str,
+            arg_value: &str,
+        ) -> Result<String> {
+            Ok(arg_value.to_string())
+        }
     }
 
     #[tokio::test]
@@ -228,6 +239,15 @@ mod parse_and_render_tests {
             async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String> {
                 Ok(format!("{fn_name}: {}, {:?} {:?}", args.len(), args.get("a"), args.get("b")))
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                arg_value: &str,
+            ) -> Result<String> {
+                Ok(arg_value.to_string())
+            }
         }
         assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result);
         Ok(())
@@ -247,6 +267,15 @@ mod parse_and_render_tests {
                     _ => "".to_string(),
                 })
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                _arg_value: &str,
+            ) -> Result<String> {
+                todo!()
+            }
         }
 
         assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
@@ -267,6 +296,15 @@ mod parse_and_render_tests {
                     _ => "".to_string(),
                 })
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                _arg_value: &str,
+            ) -> Result<String> {
+                todo!()
+            }
         }
 
         assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
@@ -288,6 +326,44 @@ mod parse_and_render_tests {
                     _ => "".to_string(),
                 })
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                _arg_value: &str,
+            ) -> Result<String> {
+                todo!()
+            }
+        }
+
+        assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn render_fn_return_template() -> Result<()> {
+        let mut vars = HashMap::new();
+        vars.insert("foo".to_string(), "bar".to_string());
+        let template = r#"${[ no_op(inner='${[ foo ]}') ]}"#;
+        let result = r#"bar"#;
+        struct CB {}
+        impl TemplateCallback for CB {
+            async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String> {
+                Ok(match fn_name {
+                    "no_op" => args["inner"].to_string(),
+                    _ => "".to_string(),
+                })
+            }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                _arg_value: &str,
+            ) -> Result<String> {
+                todo!()
+            }
         }
 
         assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
@@ -308,6 +384,15 @@ mod parse_and_render_tests {
                     _ => "".to_string(),
                 })
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                arg_value: &str,
+            ) -> Result<String> {
+                Ok(arg_value.to_string())
+            }
         }
 
         assert_eq!(parse_and_render(template, &vars, &CB {}).await?, result.to_string());
@@ -324,6 +409,15 @@ mod parse_and_render_tests {
             async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
                 Err(RenderError("Failed to do it!".to_string()))
             }
+
+            fn transform_arg(
+                &self,
+                _fn_name: &str,
+                _arg_name: &str,
+                arg_value: &str,
+            ) -> Result<String> {
+                Ok(arg_value.to_string())
+            }
         }
 
         assert_eq!(
@@ -337,7 +431,7 @@ mod parse_and_render_tests {
 #[cfg(test)]
 mod render_json_value_raw_tests {
     use crate::error::Result;
-    use crate::{render_json_value_raw, TemplateCallback};
+    use crate::{TemplateCallback, render_json_value_raw};
     use serde_json::json;
     use std::collections::HashMap;
 
@@ -347,6 +441,15 @@ mod render_json_value_raw_tests {
         async fn run(&self, _fn_name: &str, _args: HashMap<String, String>) -> Result<String> {
             todo!()
         }
+
+        fn transform_arg(
+            &self,
+            _fn_name: &str,
+            _arg_name: &str,
+            arg_value: &str,
+        ) -> Result<String> {
+            Ok(arg_value.to_string())
+        }
     }
 
     #[tokio::test]

src-tauri/yaak-templates/src/wasm.rs

@@ -0,0 +1,10 @@
+use crate::error::Result;
+use crate::Parser;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen]
+pub fn parse_template(template: &str) -> Result<JsValue> {
+    let tokens = Parser::new(template).parse()?;
+    Ok(serde_wasm_bindgen::to_value(&tokens).unwrap())
+}