Request actions (#65)

src-tauri/yaak_plugin_runtime/src/events.rs

@@ -32,13 +32,24 @@ pub enum InternalEventPayload {
 
     ExportHttpRequestRequest(ExportHttpRequestRequest),
     ExportHttpRequestResponse(ExportHttpRequestResponse),
-    
+
     SendHttpRequestRequest(SendHttpRequestRequest),
     SendHttpRequestResponse(SendHttpRequestResponse),
 
+    GetHttpRequestActionsRequest,
+    GetHttpRequestActionsResponse(GetHttpRequestActionsResponse),
+    CallHttpRequestActionRequest(CallHttpRequestActionRequest),
+
+    CopyTextRequest(CopyTextRequest),
+
+    RenderHttpRequestRequest(RenderHttpRequestRequest),
+    RenderHttpRequestResponse(RenderHttpRequestResponse),
+
+    ShowToastRequest(ShowToastRequest),
+
     GetHttpRequestByIdRequest(GetHttpRequestByIdRequest),
     GetHttpRequestByIdResponse(GetHttpRequestByIdResponse),
-    
+
     /// Returned when a plugin doesn't get run, just so the server
     /// has something to listen for
     EmptyResponse(EmptyResponse),
@@ -122,6 +133,86 @@ pub struct SendHttpRequestResponse {
     pub http_response: HttpResponse,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct CopyTextRequest {
+    pub text: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct RenderHttpRequestRequest {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct RenderHttpRequestResponse {
+    pub http_request: HttpRequest,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct ShowToastRequest {
+    pub message: String,
+    pub variant: ToastVariant,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export)]
+pub enum ToastVariant {
+    Custom,
+    Copied,
+    Success,
+    Info,
+    Warning,
+    Error,
+}
+
+impl Default for ToastVariant {
+    fn default() -> Self {
+        ToastVariant::Info
+    }
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct GetHttpRequestActionsResponse {
+    pub actions: Vec<HttpRequestAction>,
+    pub plugin_ref_id: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct HttpRequestAction {
+    pub key: String,
+    pub label: String,
+    pub icon: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct CallHttpRequestActionRequest {
+    pub key: String,
+    pub plugin_ref_id: String,
+    pub args: CallHttpRequestActionArgs,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export)]
+pub struct CallHttpRequestActionArgs {
+    pub http_request: HttpRequest,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export)]

src-tauri/yaak_plugin_runtime/src/manager.rs

@@ -1,8 +1,5 @@
 use crate::error::Result;
-use crate::events::{
-    ExportHttpRequestRequest, ExportHttpRequestResponse, FilterRequest, FilterResponse
-    , ImportRequest, ImportResponse, InternalEvent, InternalEventPayload,
-};
+use crate::events::{CallHttpRequestActionRequest, FilterRequest, FilterResponse, GetHttpRequestActionsResponse, ImportRequest, ImportResponse, InternalEvent, InternalEventPayload};
 
 use crate::error::Error::PluginErr;
 use crate::nodejs::start_nodejs_plugin_runtime;
@@ -12,7 +9,6 @@ use std::time::Duration;
 use tauri::{AppHandle, Runtime};
 use tokio::sync::mpsc;
 use tokio::sync::watch::Sender;
-use yaak_models::models::HttpRequest;
 
 pub struct PluginManager {
     kill_tx: Sender<bool>,
@@ -61,6 +57,29 @@ impl PluginManager {
             .send(&payload, source_event.plugin_ref_id.as_str(), reply_id)
             .await
     }
+    
+    pub async fn run_http_request_actions(&self) -> Result<Vec<GetHttpRequestActionsResponse>> {
+        let reply_events = self
+            .server
+            .send_and_wait(&InternalEventPayload::GetHttpRequestActionsRequest)
+            .await?;
+
+        let mut all_actions = Vec::new();
+        for event in reply_events {
+            if let InternalEventPayload::GetHttpRequestActionsResponse(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);
+        plugin.send(&event).await?;
+        Ok(())
+    }
 
     pub async fn run_import(&self, content: &str) -> Result<(ImportResponse, String)> {
         let reply_events = self
@@ -72,43 +91,17 @@ impl PluginManager {
 
         // TODO: Don't just return the first valid response
         for event in reply_events {
-            match event.payload {
-                InternalEventPayload::ImportResponse(resp) => {
-                    let ref_id = event.plugin_ref_id.as_str();
-                    let plugin = self.server.plugin_by_ref_id(ref_id).await?;
-                    let plugin_name = plugin.name().await;
-                    return Ok((resp, plugin_name));
-                }
-                _ => {}
+            if let InternalEventPayload::ImportResponse(resp) = event.payload {
+                let ref_id = event.plugin_ref_id.as_str();
+                let plugin = self.server.plugin_by_ref_id(ref_id).await?;
+                let plugin_name = plugin.name().await;
+                return Ok((resp, plugin_name));
             }
         }
 
         Err(PluginErr("No import responses found".to_string()))
     }
 
-    pub async fn run_export_curl(
-        &self,
-        request: &HttpRequest,
-    ) -> Result<ExportHttpRequestResponse> {
-        let event = self
-            .server
-            .send_to_plugin_and_wait(
-                "exporter-curl",
-                &InternalEventPayload::ExportHttpRequestRequest(ExportHttpRequestRequest {
-                    http_request: request.to_owned(),
-                }),
-            )
-            .await?;
-
-        match event.payload {
-            InternalEventPayload::ExportHttpRequestResponse(resp) => Ok(resp),
-            InternalEventPayload::EmptyResponse(_) => {
-                Err(PluginErr("Export returned empty".to_string()))
-            }
-            e => Err(PluginErr(format!("Export returned invalid event {:?}", e))),
-        }
-    }
-
     pub async fn run_filter(
         &self,
         filter: &str,