Async template functions working

src-tauri/yaak_plugin_runtime/src/events.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 use ts_rs::TS;
 
@@ -17,8 +18,7 @@ pub struct InternalEvent {
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, TS)]
-#[serde(tag = "type")]
-#[serde(rename_all = "snake_case")]
+#[serde(rename_all = "snake_case", tag = "type")]
 #[ts(export)]
 pub enum InternalEventPayload {
     BootRequest(BootRequest),
@@ -40,6 +40,10 @@ pub enum InternalEventPayload {
     GetHttpRequestActionsResponse(GetHttpRequestActionsResponse),
     CallHttpRequestActionRequest(CallHttpRequestActionRequest),
 
+    GetTemplateFunctionsRequest,
+    GetTemplateFunctionsResponse(GetTemplateFunctionsResponse),
+    CallTemplateFunctionRequest(CallTemplateFunctionRequest),
+
     CopyTextRequest(CopyTextRequest),
 
     RenderHttpRequestRequest(RenderHttpRequestRequest),
@@ -180,6 +184,110 @@ impl Default for ToastVariant {
     }
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct GetTemplateFunctionsResponse {
+    pub functions: Vec<TemplateFunction>,
+    pub plugin_ref_id: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunction {
+    pub name: String,
+    pub args: Vec<TemplateFunctionArg>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export)]
+pub enum TemplateFunctionArg {
+    Text(TemplateFunctionTextArg),
+    Select(TemplateFunctionSelectArg),
+    HttpRequest(TemplateFunctionHttpRequestArg),
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunctionBaseArg {
+    pub name: String,
+    #[ts(optional = nullable)]
+    pub optional: Option<bool>,
+    #[ts(optional = nullable)]
+    pub label: Option<String>,
+    #[ts(optional = nullable)]
+    pub default_value: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunctionTextArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+    #[ts(optional = nullable)]
+    pub placeholder: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunctionHttpRequestArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunctionSelectArg {
+    #[serde(flatten)]
+    pub base: TemplateFunctionBaseArg,
+    pub options: Vec<TemplateFunctionSelectOption>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct TemplateFunctionSelectOption {
+    pub name: String,
+    pub value: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct CallTemplateFunctionRequest {
+    pub name: String,
+    pub plugin_ref_id: String,
+    pub args: CallTemplateFunctionArgs,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct CallTemplateFunctionArgs {
+    pub purpose: CallTemplateFunctionPurpose,
+    pub values: HashMap<String, String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export)]
+pub enum CallTemplateFunctionPurpose {
+    Send,
+    Preview,
+}
+
+impl Default for CallTemplateFunctionPurpose{
+    fn default() -> Self {
+        CallTemplateFunctionPurpose::Preview
+    }
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export)]

src-tauri/yaak_plugin_runtime/src/manager.rs

@@ -1,5 +1,5 @@
 use crate::error::Result;
-use crate::events::{CallHttpRequestActionRequest, FilterRequest, FilterResponse, GetHttpRequestActionsResponse, ImportRequest, ImportResponse, InternalEvent, InternalEventPayload};
+use crate::events::{CallHttpRequestActionRequest, CallTemplateFunctionRequest, FilterRequest, FilterResponse, GetHttpRequestActionsResponse, GetTemplateFunctionsResponse, ImportRequest, ImportResponse, InternalEvent, InternalEventPayload};
 
 use crate::error::Error::PluginErr;
 use crate::nodejs::start_nodejs_plugin_runtime;
@@ -74,6 +74,22 @@ impl PluginManager {
         Ok(all_actions)
     }
 
+    pub async fn run_template_functions(&self) -> Result<Vec<GetTemplateFunctionsResponse>> {
+        let reply_events = self
+            .server
+            .send_and_wait(&InternalEventPayload::GetTemplateFunctionsRequest)
+            .await?;
+
+        let mut all_actions = Vec::new();
+        for event in reply_events {
+            if let InternalEventPayload::GetTemplateFunctionsResponse(resp) = event.payload {
+                all_actions.push(resp.clone());
+            }
+        }
+
+        Ok(all_actions)
+    }
+
     pub async fn call_http_request_action(&self, req: CallHttpRequestActionRequest) -> Result<()> {
         let plugin = self.server.plugin_by_ref_id(req.plugin_ref_id.as_str()).await?;
         let event = plugin.build_event_to_send(&InternalEventPayload::CallHttpRequestActionRequest(req), None);
@@ -81,6 +97,13 @@ impl PluginManager {
         Ok(())
     }
 
+    pub async fn call_template_function(&self, req: CallTemplateFunctionRequest) -> Result<()> {
+        let plugin = self.server.plugin_by_ref_id(req.plugin_ref_id.as_str()).await?;
+        let event = plugin.build_event_to_send(&InternalEventPayload::CallTemplateFunctionRequest(req), None);
+        plugin.send(&event).await?;
+        Ok(())
+    }
+
     pub async fn run_import(&self, content: &str) -> Result<(ImportResponse, String)> {
         let reply_events = self
             .server