collection plugin actions

src-tauri/src/lib.rs

@@ -43,7 +43,8 @@ use yaak_plugins::events::{
     CallGrpcRequestActionArgs, CallGrpcRequestActionRequest, CallHttpRequestActionArgs,
     CallHttpRequestActionRequest, Color, FilterResponse, GetGrpcRequestActionsResponse,
     GetHttpAuthenticationConfigResponse, GetHttpAuthenticationSummaryResponse,
-    GetHttpRequestActionsResponse, GetTemplateFunctionConfigResponse,
+    GetHttpRequestActionsResponse, GetHttpCollectionActionsResponse,
+    CallHttpCollectionActionArgs, CallHttpCollectionActionRequest, GetTemplateFunctionConfigResponse,
     GetTemplateFunctionSummaryResponse, InternalEvent, InternalEventPayload, JsonPrimitive,
     PluginContext, RenderPurpose, ShowToastRequest,
 };
@@ -846,6 +847,40 @@ async fn cmd_http_request_actions<R: Runtime>(
     Ok(plugin_manager.get_http_request_actions(&window).await?)
 }
 
+#[tauri::command]
+async fn cmd_http_collection_actions<R: Runtime>(
+    window: WebviewWindow<R>,
+    plugin_manager: State<'_, PluginManager>,
+) -> YaakResult<Vec<GetHttpCollectionActionsResponse>> {
+    Ok(plugin_manager.get_http_collection_actions(&window).await?)
+}
+
+#[tauri::command]
+async fn cmd_call_http_collection_action<R: Runtime>(
+    window: WebviewWindow<R>,
+    req: CallHttpCollectionActionRequest,
+    plugin_manager: State<'_, PluginManager>,
+) -> YaakResult<()> {
+    let folder = match &req.args.folder {
+        Some(f) => Some(window.db().get_folder(&f.id)?),
+        None => None,
+    };
+    let workspace = match &req.args.workspace {
+        Some(w) => Some(window.db().get_workspace(&w.id)?),
+        None => None,
+    };
+
+    Ok(plugin_manager
+        .call_http_collection_action(
+            &window,
+            CallHttpCollectionActionRequest {
+                args: CallHttpCollectionActionArgs { folder, workspace },
+                ..req
+            },
+        )
+        .await?)
+}
+
 #[tauri::command]
 async fn cmd_grpc_request_actions<R: Runtime>(
     window: WebviewWindow<R>,
@@ -1448,6 +1483,7 @@ pub fn run() {
         .invoke_handler(tauri::generate_handler![
             cmd_call_http_authentication_action,
             cmd_call_http_request_action,
+            cmd_call_http_collection_action,
             cmd_call_grpc_request_action,
             cmd_check_for_updates,
             cmd_create_grpc_request,
@@ -1467,6 +1503,7 @@ pub fn run() {
             cmd_grpc_reflect,
             cmd_grpc_request_actions,
             cmd_http_request_actions,
+            cmd_http_collection_actions,
             cmd_import_data,
             cmd_install_plugin,
             cmd_metadata,

src-tauri/src/plugin_events.rs

@@ -20,6 +20,7 @@ use yaak_plugins::error::Error::PluginErr;
 use yaak_plugins::events::{
     Color, DeleteKeyValueResponse, EmptyPayload, ErrorResponse, FindHttpResponsesResponse,
     GetCookieValueResponse, GetHttpRequestByIdResponse, GetKeyValueResponse, Icon, InternalEvent,
+    ListHttpRequestsResponse,
     InternalEventPayload, ListCookieNamesResponse, RenderGrpcRequestResponse,
     RenderHttpRequestResponse, SendHttpRequestResponse, SetKeyValueResponse, ShowToastRequest,
     TemplateRenderResponse, WindowInfoResponse, WindowNavigateEvent,
@@ -60,6 +61,30 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                 http_responses,
             })))
         }
+        InternalEventPayload::ListHttpRequestsRequest(req) => {
+            let mut http_requests = Vec::new();
+            if let Some(folder_id) = req.folder_id {
+                http_requests = app_handle
+                    .db()
+                    .list_http_requests_for_folder_recursive(&folder_id)?;
+            } else if let Some(workspace_id) = req.workspace_id {
+                http_requests = app_handle.db().list_http_requests(&workspace_id)?;
+            }
+
+            Ok(Some(InternalEventPayload::ListHttpRequestsResponse(ListHttpRequestsResponse {
+                http_requests,
+            })))
+        }
+        InternalEventPayload::ListFoldersRequest(req) => {
+            let mut folders = Vec::new();
+            if let Some(workspace_id) = req.workspace_id {
+                folders = app_handle.db().list_folders(&workspace_id)?;
+            }
+
+            Ok(Some(InternalEventPayload::ListFoldersResponse(
+                yaak_plugins::events::ListFoldersResponse { folders },
+            )))
+        }
         InternalEventPayload::GetHttpRequestByIdRequest(req) => {
             let http_request = app_handle.db().get_http_request(&req.id).ok();
             Ok(Some(InternalEventPayload::GetHttpRequestByIdResponse(GetHttpRequestByIdResponse {
@@ -352,6 +377,26 @@ pub(crate) async fn handle_plugin_event<R: Runtime>(
                 environment_id,
             })))
         }
+        InternalEventPayload::WriteTextFileRequest(req) => {
+            use std::fs;
+            use std::path::Path;
+            
+            // Ensure the directory exists
+            if let Some(parent) = Path::new(&req.file_path).parent() {
+                fs::create_dir_all(parent)?;
+            }
+            
+            fs::write(&req.file_path, &req.content)?;
+            Ok(Some(InternalEventPayload::WriteTextFileResponse(EmptyPayload {})))
+        }
+        InternalEventPayload::ReadTextFileRequest(req) => {
+            use std::fs;
+            
+            let content = fs::read_to_string(&req.file_path)?;
+            Ok(Some(InternalEventPayload::ReadTextFileResponse(
+                yaak_plugins::events::ReadTextFileResponse { content },
+            )))
+        }
         _ => Ok(None),
     }
 }

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

@@ -89,6 +89,10 @@ pub enum InternalEventPayload {
     GetHttpRequestActionsRequest(EmptyPayload),
     GetHttpRequestActionsResponse(GetHttpRequestActionsResponse),
     CallHttpRequestActionRequest(CallHttpRequestActionRequest),
+    // HTTP Collection Actions
+    GetHttpCollectionActionsRequest(EmptyPayload),
+    GetHttpCollectionActionsResponse(GetHttpCollectionActionsResponse),
+    CallHttpCollectionActionRequest(CallHttpCollectionActionRequest),
 
     // Grpc Request Actions
     GetGrpcRequestActionsRequest(EmptyPayload),
@@ -151,10 +155,19 @@ pub enum InternalEventPayload {
 
     FindHttpResponsesRequest(FindHttpResponsesRequest),
     FindHttpResponsesResponse(FindHttpResponsesResponse),
+    ListHttpRequestsRequest(ListHttpRequestsRequest),
+    ListHttpRequestsResponse(ListHttpRequestsResponse),
+    ListFoldersRequest(ListFoldersRequest),
+    ListFoldersResponse(ListFoldersResponse),
 
     GetThemesRequest(GetThemesRequest),
     GetThemesResponse(GetThemesResponse),
 
+    WriteTextFileRequest(WriteTextFileRequest),
+    WriteTextFileResponse(EmptyPayload),
+    ReadTextFileRequest(ReadTextFileRequest),
+    ReadTextFileResponse(ReadTextFileResponse),
+
     /// Returned when a plugin doesn't get run, just so the server
     /// has something to listen for
     EmptyResponse(EmptyPayload),
@@ -1096,6 +1109,14 @@ pub struct GetHttpRequestActionsResponse {
     pub plugin_ref_id: String,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct GetHttpCollectionActionsResponse {
+    pub actions: Vec<HttpCollectionAction>,
+    pub plugin_ref_id: String,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
@@ -1105,6 +1126,15 @@ pub struct HttpRequestAction {
     pub icon: Option<Icon>,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct HttpCollectionAction {
+    pub label: String,
+    #[ts(optional)]
+    pub icon: Option<Icon>,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
@@ -1114,6 +1144,15 @@ pub struct CallHttpRequestActionRequest {
     pub args: CallHttpRequestActionArgs,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct CallHttpCollectionActionRequest {
+    pub index: i32,
+    pub plugin_ref_id: String,
+    pub args: CallHttpCollectionActionArgs,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
@@ -1121,6 +1160,16 @@ pub struct CallHttpRequestActionArgs {
     pub http_request: HttpRequest,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct CallHttpCollectionActionArgs {
+    #[ts(optional)]
+    pub folder: Option<Folder>,
+    #[ts(optional)]
+    pub workspace: Option<Workspace>,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
@@ -1185,6 +1234,38 @@ pub struct FindHttpResponsesResponse {
     pub http_responses: Vec<HttpResponse>,
 }
 
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ListHttpRequestsRequest {
+    #[ts(optional)]
+    pub folder_id: Option<String>,
+    #[ts(optional)]
+    pub workspace_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ListHttpRequestsResponse {
+    pub http_requests: Vec<HttpRequest>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ListFoldersRequest {
+    #[ts(optional)]
+    pub workspace_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ListFoldersResponse {
+    pub folders: Vec<Folder>,
+}
+
 #[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
 #[serde(default, rename_all = "camelCase")]
 #[ts(export, export_to = "gen_events.ts")]
@@ -1238,3 +1319,25 @@ pub struct DeleteKeyValueRequest {
 pub struct DeleteKeyValueResponse {
     pub deleted: bool,
 }
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct WriteTextFileRequest {
+    pub file_path: String,
+    pub content: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ReadTextFileRequest {
+    pub file_path: String,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize, TS)]
+#[serde(default, rename_all = "camelCase")]
+#[ts(export, export_to = "gen_events.ts")]
+pub struct ReadTextFileResponse {
+    pub content: String,
+}

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

@@ -10,6 +10,7 @@ use crate::events::{
     FilterRequest, FilterResponse, GetGrpcRequestActionsResponse,
     GetHttpAuthenticationConfigRequest, GetHttpAuthenticationConfigResponse,
     GetHttpAuthenticationSummaryResponse, GetHttpRequestActionsResponse,
+    GetHttpCollectionActionsResponse, CallHttpCollectionActionRequest,
     GetTemplateFunctionConfigRequest, GetTemplateFunctionConfigResponse,
     GetTemplateFunctionSummaryResponse, GetThemesRequest, GetThemesResponse, ImportRequest,
     ImportResponse, InternalEvent, InternalEventPayload, JsonPrimitive, PluginContext,
@@ -482,6 +483,27 @@ impl PluginManager {
         Ok(all_actions)
     }
 
+    pub async fn get_http_collection_actions<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+    ) -> Result<Vec<GetHttpCollectionActionsResponse>> {
+        let reply_events = self
+            .send_and_wait(
+                &PluginContext::new(window),
+                &InternalEventPayload::GetHttpCollectionActionsRequest(EmptyPayload {}),
+            )
+            .await?;
+
+        let mut all_actions = Vec::new();
+        for event in reply_events {
+            if let InternalEventPayload::GetHttpCollectionActionsResponse(resp) = event.payload {
+                all_actions.push(resp.clone());
+            }
+        }
+
+        Ok(all_actions)
+    }
+
     pub async fn get_template_function_config<R: Runtime>(
         &self,
         window: &WebviewWindow<R>,
@@ -564,6 +586,23 @@ impl PluginManager {
         Ok(())
     }
 
+    pub async fn call_http_collection_action<R: Runtime>(
+        &self,
+        window: &WebviewWindow<R>,
+        req: CallHttpCollectionActionRequest,
+    ) -> Result<()> {
+        let ref_id = req.plugin_ref_id.clone();
+        let plugin =
+            self.get_plugin_by_ref_id(ref_id.as_str()).await.ok_or(PluginNotFoundErr(ref_id))?;
+        let event = plugin.build_event_to_send(
+            &PluginContext::new(window),
+            &InternalEventPayload::CallHttpCollectionActionRequest(req),
+            None,
+        );
+        plugin.send(&event).await?;
+        Ok(())
+    }
+
     pub async fn call_grpc_request_action<R: Runtime>(
         &self,
         window: &WebviewWindow<R>,