Make rendering return Result, and handle infinite recursion

src-tauri/Cargo.toml

@@ -42,7 +42,6 @@ openssl-sys = { version = "0.9.105", features = ["vendored"] } # For Ubuntu inst
 
 [dependencies]
 chrono = { version = "0.4.31", features = ["serde"] }
-datetime = "0.5.2"
 encoding_rs = "0.8.35"
 eventsource-client = { git = "https://github.com/yaakapp/rust-eventsource-client", version = "0.14.0" }
 hex_color = "3.0.0"
@@ -71,7 +70,7 @@ tauri-plugin-updater = "2.5.0"
 tauri-plugin-window-state = "2.2.1"
 tokio = { version = "1.43.0", features = ["sync"] }
 tokio-stream = "0.1.17"
-ts-rs = { workspace = true }
+thiserror = { workspace = true }
 uuid = "1.12.1"
 yaak-git = { path = "yaak-git" }
 yaak-grpc = { path = "yaak-grpc" }

src-tauri/src/error.rs

@@ -0,0 +1,43 @@
+use serde::{Serialize, Serializer};
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum Error {
+    #[error("Render error: {0}")]
+    TemplateError(#[from] yaak_templates::error::Error),
+
+    #[error("Model error: {0}")]
+    ModelError(#[from] yaak_models::error::Error),
+
+    #[error("Sync error: {0}")]
+    SyncError(#[from] yaak_sync::error::Error),
+
+    #[error("Git error: {0}")]
+    GitError(#[from] yaak_git::error::Error),
+
+    #[error("Websocket error: {0}")]
+    WebsocketError(#[from] yaak_ws::error::Error),
+
+    #[error("License error: {0}")]
+    LicenseError(#[from] yaak_license::error::Error),
+
+    #[error("Plugin error: {0}")]
+    PluginError(#[from] yaak_plugins::error::Error),
+
+    #[error("Request error: {0}")]
+    RequestError(#[from] reqwest::Error),
+
+    #[error("Generic error: {0}")]
+    GenericError(String),
+}
+
+impl Serialize for Error {
+    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(self.to_string().as_ref())
+    }
+}
+
+pub type Result<T> = std::result::Result<T, Error>;

src-tauri/src/http_request.rs

@@ -1,3 +1,5 @@
+use crate::error::Error::GenericError;
+use crate::error::Result;
 use crate::render::render_http_request;
 use crate::response_err;
 use http::header::{ACCEPT, USER_AGENT};
@@ -43,14 +45,10 @@ pub async fn send_http_request<R: Runtime>(
     environment: Option<Environment>,
     cookie_jar: Option<CookieJar>,
     cancelled_rx: &mut Receiver<bool>,
-) -> Result<HttpResponse, String> {
+) -> Result<HttpResponse> {
     let plugin_manager = window.state::<PluginManager>();
-    let workspace = get_workspace(window, &unrendered_request.workspace_id)
-        .await
-        .expect("Failed to get Workspace");
-    let base_environment = get_base_environment(window, &unrendered_request.workspace_id)
-        .await
-        .expect("Failed to get base environment");
+    let workspace = get_workspace(window, &unrendered_request.workspace_id).await?;
+    let base_environment = get_base_environment(window, &unrendered_request.workspace_id).await?;
     let settings = get_or_create_settings(window).await;
     let cb = PluginTemplateCallback::new(
         window.app_handle(),
@@ -61,9 +59,17 @@ pub async fn send_http_request<R: Runtime>(
     let response_id = og_response.id.clone();
     let response = Arc::new(Mutex::new(og_response.clone()));
 
-    let request =
-        render_http_request(&unrendered_request, &base_environment, environment.as_ref(), &cb)
-            .await;
+    let request = match render_http_request(
+        &unrendered_request,
+        &base_environment,
+        environment.as_ref(),
+        &cb,
+    )
+    .await
+    {
+        Ok(r) => r,
+        Err(e) => return Ok(response_err(&*response.lock().await, e.to_string(), window).await),
+    };
 
     let mut url_string = request.url;
 
@@ -139,10 +145,9 @@ pub async fn send_http_request<R: Runtime>(
                     serde_json::from_value(json_cookie).expect("Failed to deserialize cookie")
                 })
                 .map(|c| Ok(c))
-                .collect::<Vec<Result<_, ()>>>();
+                .collect::<Vec<Result<_>>>();
 
-            let store = reqwest_cookie_store::CookieStore::from_cookies(cookies, true)
-                .expect("Failed to create cookie store");
+            let store = reqwest_cookie_store::CookieStore::from_cookies(cookies, true)?;
             let cookie_store = reqwest_cookie_store::CookieStoreMutex::new(store);
             let cookie_store = Arc::new(cookie_store);
             client_builder = client_builder.cookie_provider(Arc::clone(&cookie_store));
@@ -158,7 +163,7 @@ pub async fn send_http_request<R: Runtime>(
         ));
     }
 
-    let client = client_builder.build().expect("Failed to build client");
+    let client = client_builder.build()?;
 
     // Render query parameters
     let mut query_params = Vec::new();
@@ -193,8 +198,8 @@ pub async fn send_http_request<R: Runtime>(
         }
     };
 
-    let m = Method::from_bytes(request.method.to_uppercase().as_bytes())
-        .expect("Failed to create method");
+    let m = Method::from_str(&request.method.to_uppercase())
+        .map_err(|e| GenericError(e.to_string()))?;
     let mut request_builder = client.request(m, url).query(&query_params);
 
     let mut headers = HeaderMap::new();
@@ -282,7 +287,7 @@ pub async fn send_http_request<R: Runtime>(
         } else if body_type == "binary" && request_body.contains_key("filePath") {
             let file_path = request_body
                 .get("filePath")
-                .ok_or("filePath not set")?
+                .ok_or(GenericError("filePath not set".to_string()))?
                 .as_str()
                 .unwrap_or_default();
 
@@ -431,7 +436,7 @@ pub async fn send_http_request<R: Runtime>(
         }
     }
 
-    let (resp_tx, resp_rx) = oneshot::channel::<Result<Response, reqwest::Error>>();
+    let (resp_tx, resp_rx) = oneshot::channel::<std::result::Result<Response, reqwest::Error>>();
     let (done_tx, done_rx) = oneshot::channel::<HttpResponse>();
 
     let start = std::time::Instant::now();