Make rendering return Result, and handle infinite recursion

src-tauri/yaak-plugins/src/manager.rs

@@ -27,6 +27,7 @@ use tokio::net::TcpListener;
 use tokio::sync::{mpsc, Mutex};
 use tokio::time::timeout;
 use yaak_models::queries::{generate_id, list_plugins};
+use yaak_templates::error::Error::RenderError;
 
 #[derive(Clone)]
 pub struct PluginManager {
@@ -596,7 +597,7 @@ impl PluginManager {
         fn_name: &str,
         args: HashMap<String, String>,
         purpose: RenderPurpose,
-    ) -> Result<Option<String>> {
+    ) -> yaak_templates::error::Result<String> {
         let req = CallTemplateFunctionRequest {
             name: fn_name.to_string(),
             args: CallTemplateFunctionArgs {
@@ -607,7 +608,8 @@ impl PluginManager {
 
         let events = self
             .send_and_wait(window_context, &InternalEventPayload::CallTemplateFunctionRequest(req))
-            .await?;
+            .await
+            .map_err(|e| RenderError(format!("Failed to call template function {e:}")))?;
 
         let value = events.into_iter().find_map(|e| match e.payload {
             InternalEventPayload::CallTemplateFunctionResponse(CallTemplateFunctionResponse {
@@ -616,7 +618,10 @@ impl PluginManager {
             _ => None,
         });
 
-        Ok(value)
+        match value {
+            None => Err(RenderError(format!("Template function not found {fn_name}"))),
+            Some(v) => Ok(v),
+        }
     }
 
     pub async fn import_data<R: Runtime>(

src-tauri/yaak-plugins/src/template_callback.rs

@@ -1,7 +1,8 @@
-use crate::events::{FormInput, RenderPurpose, WindowContext};
+use crate::events::{RenderPurpose, WindowContext};
 use crate::manager::PluginManager;
 use std::collections::HashMap;
 use tauri::{AppHandle, Manager, Runtime};
+use yaak_templates::error::Result;
 use yaak_templates::TemplateCallback;
 
 #[derive(Clone)]
@@ -27,51 +28,20 @@ impl PluginTemplateCallback {
 }
 
 impl TemplateCallback for PluginTemplateCallback {
-    async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String, String> {
+    async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String> {
         // The beta named the function `Response` but was changed in stable.
         // Keep this here for a while because there's no easy way to migrate
         let fn_name = if fn_name == "Response" { "response" } else { fn_name };
 
-        let function = self
-            .plugin_manager
-            .get_template_functions_with_context(&self.window_context)
-            .await
-            .map_err(|e| e.to_string())?
-            .iter()
-            .flat_map(|f| f.functions.clone())
-            .find(|f| f.name == fn_name)
-            .ok_or("")?;
-
-        let mut args_with_defaults = args.clone();
-
-        // Fill in default values for all args
-        for arg in function.args {
-            let base = match arg {
-                FormInput::Text(a) => a.base,
-                FormInput::Editor(a) => a.base,
-                FormInput::Select(a) => a.base,
-                FormInput::Checkbox(a) => a.base,
-                FormInput::File(a) => a.base,
-                FormInput::HttpRequest(a) => a.base,
-                FormInput::Accordion(_) => continue,
-                FormInput::Banner(_) => continue,
-                FormInput::Markdown(_) => continue,
-            };
-            if let None = args_with_defaults.get(base.name.as_str()) {
-                args_with_defaults.insert(base.name, base.default_value.unwrap_or_default());
-            }
-        }
-
         let resp = self
             .plugin_manager
             .call_template_function(
                 &self.window_context,
                 fn_name,
-                args_with_defaults,
+                args,
                 self.render_purpose.to_owned(),
             )
-            .await
-            .map_err(|e| e.to_string())?;
-        Ok(resp.unwrap_or_default())
+            .await?;
+        Ok(resp)
     }
 }