starred/yaak
1
0
Fork 0
mirror of https://github.com/mountain-loop/yaak.git synced 2026-03-17 23:14:03 +01:00
Code Issues 8 Packages Projects Releases 10 Wiki Activity

Upgrade to Tauri 2.0 (#23)

Browse Source
This commit is contained in:
Gregory Schier
2024-05-04 14:14:19 -07:00
committed by GitHub
parent 7f02060b9c
commit 896e3d5831
128 changed files with 20477 additions and 4114 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src-tauri/src/analytics.rs
View File

@@ -208,7 +208,7 @@ fn get_os() -> &'static str {
}
fn get_window_size(app_handle: &AppHandle) -> String {
let window = match app_handle.windows().into_values().next() {
let window = match app_handle.webview_windows().into_values().next() {
Some(w) => w,
None => return "unknown".to_string(),
};

11
src-tauri/src/http.rs
View File

@@ -7,20 +7,20 @@ use std::sync::Arc;
use std::time::Duration;
use base64::Engine;
use http::header::{ACCEPT, USER_AGENT};
use http::{HeaderMap, HeaderName, HeaderValue, Method};
use http::header::{ACCEPT, USER_AGENT};
use log::{error, info, warn};
use reqwest::redirect::Policy;
use reqwest::{multipart, Url};
use reqwest::redirect::Policy;
use sqlx::types::{Json, JsonValue};
use tauri::{Manager, Window};
use tauri::{Manager, WebviewWindow};
use tokio::sync::oneshot;
use tokio::sync::watch::Receiver;
use crate::{models, render, response_err};
pub async fn send_http_request(
window: &Window,
window: &WebviewWindow,
request: models::HttpRequest,
response: &models::HttpResponse,
environment: Option<models::Environment>,
@@ -112,7 +112,6 @@ pub async fn send_http_request(
// everything manually to know that).
// if let Some(cookie_store) = maybe_cookie_store.clone() {
// let values1 = cookie_store.get_request_values(&url);
// println!("COOKIE VLUAES: {:?}", values1.collect::<Vec<_>>());
// let raw_value = cookie_store.get_request_values(&url)
// .map(|(name, value)| format!("{}={}", name, value))
// .collect::<Vec<_>>()
@@ -401,7 +400,7 @@ pub async fn send_http_request(
{
// Write body to FS
let dir = window.app_handle().path_resolver().app_data_dir().unwrap();
let dir = window.app_handle().path().app_data_dir().unwrap();
let base_dir = dir.join("responses");
create_dir_all(base_dir.clone()).expect("Failed to create responses dir");
let body_path = match response.id.is_empty() {

1721
src-tauri/src/lib.rs Normal file
View File

File diff suppressed because it is too large Load Diff

1682
src-tauri/src/main.rs
View File

File diff suppressed because it is too large Load Diff

241
src-tauri/src/models.rs
View File

@@ -4,10 +4,10 @@ use std::fs;
use log::error;
use rand::distributions::{Alphanumeric, DistString};
use serde::{Deserialize, Serialize};
use sqlx::types::chrono::NaiveDateTime;
use sqlx::types::{Json, JsonValue};
use sqlx::{Pool, Sqlite};
use tauri::{AppHandle, Manager, Wry};
use sqlx::types::{Json, JsonValue};
use sqlx::types::chrono::NaiveDateTime;
use tauri::{AppHandle, Manager, WebviewWindow, Wry};
use tokio::sync::Mutex;
fn default_true() -> bool {
@@ -426,9 +426,9 @@ pub async fn get_workspace(mgr: &impl Manager<Wry>, id: &str) -> Result<Workspac
.await
}
pub async fn delete_workspace(mgr: &impl Manager<Wry>, id: &str) -> Result<Workspace, sqlx::Error> {
let db = get_db(mgr).await;
let workspace = get_workspace(mgr, id).await?;
pub async fn delete_workspace(window: &WebviewWindow, id: &str) -> Result<Workspace, sqlx::Error> {
let db = get_db(window).await;
let workspace = get_workspace(window, id).await?;
let _ = sqlx::query!(
r#"
DELETE FROM workspaces
@@ -439,11 +439,11 @@ pub async fn delete_workspace(mgr: &impl Manager<Wry>, id: &str) -> Result<Works
.execute(&db)
.await;
for r in list_responses_by_workspace_id(mgr, id).await? {
delete_http_response(mgr, &r.id).await?;
for r in list_responses_by_workspace_id(window, id).await? {
delete_http_response(window, &r.id).await?;
}
emit_deleted_model(mgr, workspace)
emit_deleted_model(window, workspace)
}
pub async fn get_cookie_jar(mgr: &impl Manager<Wry>, id: &str) -> Result<CookieJar, sqlx::Error> {
@@ -482,11 +482,11 @@ pub async fn list_cookie_jars(
}
pub async fn delete_cookie_jar(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<CookieJar, sqlx::Error> {
let cookie_jar = get_cookie_jar(mgr, id).await?;
let db = get_db(mgr).await;
let cookie_jar = get_cookie_jar(window, id).await?;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
@@ -498,23 +498,23 @@ pub async fn delete_cookie_jar(
.execute(&db)
.await;
emit_deleted_model(mgr, cookie_jar)
emit_deleted_model(window, cookie_jar)
}
pub async fn duplicate_grpc_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<GrpcRequest, sqlx::Error> {
let mut request = get_grpc_request(mgr, id).await?.clone();
let mut request = get_grpc_request(window, id).await?.clone();
request.id = "".to_string();
upsert_grpc_request(mgr, &request).await
upsert_grpc_request(window, &request).await
}
pub async fn upsert_grpc_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
request: &GrpcRequest,
) -> Result<GrpcRequest, sqlx::Error> {
let db = get_db(mgr).await;
let db = get_db(window).await;
let id = match request.id.as_str() {
"" => generate_id(Some("gr")),
_ => request.id.to_string(),
@@ -556,8 +556,8 @@ pub async fn upsert_grpc_request(
.execute(&db)
.await?;
match get_grpc_request(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_grpc_request(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -607,10 +607,10 @@ pub async fn list_grpc_requests(
}
pub async fn upsert_grpc_connection(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
connection: &GrpcConnection,
) -> Result<GrpcConnection, sqlx::Error> {
let db = get_db(mgr).await;
let db = get_db(window).await;
let id = match connection.id.as_str() {
"" => generate_id(Some("gc")),
_ => connection.id.to_string(),
@@ -646,8 +646,8 @@ pub async fn upsert_grpc_connection(
.execute(&db)
.await?;
match get_grpc_connection(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_grpc_connection(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -696,10 +696,10 @@ pub async fn list_grpc_connections(
}
pub async fn upsert_grpc_event(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
event: &GrpcEvent,
) -> Result<GrpcEvent, sqlx::Error> {
let db = get_db(mgr).await;
let db = get_db(window).await;
let id = match event.id.as_str() {
"" => generate_id(Some("ge")),
_ => event.id.to_string(),
@@ -732,8 +732,8 @@ pub async fn upsert_grpc_event(
.execute(&db)
.await?;
match get_grpc_event(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_grpc_event(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -778,7 +778,7 @@ pub async fn list_grpc_events(
}
pub async fn upsert_cookie_jar(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
cookie_jar: &CookieJar,
) -> Result<CookieJar, sqlx::Error> {
let id = match cookie_jar.id.as_str() {
@@ -787,7 +787,7 @@ pub async fn upsert_cookie_jar(
};
let trimmed_name = cookie_jar.name.trim();
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
INSERT INTO cookie_jars (
@@ -807,8 +807,8 @@ pub async fn upsert_cookie_jar(
.execute(&db)
.await?;
match get_cookie_jar(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_cookie_jar(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -833,11 +833,11 @@ pub async fn list_environments(
}
pub async fn delete_environment(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<Environment, sqlx::Error> {
let db = get_db(mgr).await;
let env = get_environment(mgr, id).await?;
let db = get_db(window).await;
let env = get_environment(window, id).await?;
let _ = sqlx::query!(
r#"
DELETE FROM environments
@@ -848,7 +848,7 @@ pub async fn delete_environment(
.execute(&db)
.await;
emit_deleted_model(mgr, env)
emit_deleted_model(window, env)
}
async fn get_settings(mgr: &impl Manager<Wry>) -> Result<Settings, sqlx::Error> {
@@ -886,10 +886,10 @@ pub async fn get_or_create_settings(mgr: &impl Manager<Wry>) -> Settings {
}
pub async fn update_settings(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
settings: Settings,
) -> Result<Settings, sqlx::Error> {
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
UPDATE settings SET (
@@ -903,14 +903,14 @@ pub async fn update_settings(
.execute(&db)
.await?;
match get_settings(mgr).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_settings(window).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
pub async fn upsert_environment(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
environment: Environment,
) -> Result<Environment, sqlx::Error> {
let id = match environment.id.as_str() {
@@ -918,7 +918,7 @@ pub async fn upsert_environment(
_ => environment.id.to_string(),
};
let trimmed_name = environment.name.trim();
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
INSERT INTO environments (
@@ -938,8 +938,8 @@ pub async fn upsert_environment(
.execute(&db)
.await?;
match get_environment(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_environment(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -999,9 +999,9 @@ pub async fn list_folders(
.await
}
pub async fn delete_folder(mgr: &impl Manager<Wry>, id: &str) -> Result<Folder, sqlx::Error> {
let folder = get_folder(mgr, id).await?;
let db = get_db(mgr).await;
pub async fn delete_folder(window: &WebviewWindow, id: &str) -> Result<Folder, sqlx::Error> {
let folder = get_folder(window, id).await?;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
DELETE FROM folders
@@ -1012,17 +1012,17 @@ pub async fn delete_folder(mgr: &impl Manager<Wry>, id: &str) -> Result<Folder,
.execute(&db)
.await;
emit_deleted_model(mgr, folder)
emit_deleted_model(window, folder)
}
pub async fn upsert_folder(mgr: &impl Manager<Wry>, r: Folder) -> Result<Folder, sqlx::Error> {
pub async fn upsert_folder(window: &WebviewWindow, r: Folder) -> Result<Folder, sqlx::Error> {
let id = match r.id.as_str() {
"" => generate_id(Some("fl")),
_ => r.id.to_string(),
};
let trimmed_name = r.name.trim();
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
INSERT INTO folders (
@@ -1044,23 +1044,23 @@ pub async fn upsert_folder(mgr: &impl Manager<Wry>, r: Folder) -> Result<Folder,
.execute(&db)
.await?;
match get_folder(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_folder(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
pub async fn duplicate_http_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<HttpRequest, sqlx::Error> {
let mut request = get_http_request(mgr, id).await?.clone();
let mut request = get_http_request(window, id).await?.clone();
request.id = "".to_string();
upsert_http_request(mgr, request).await
upsert_http_request(window, request).await
}
pub async fn upsert_http_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
r: HttpRequest,
) -> Result<HttpRequest, sqlx::Error> {
let id = match r.id.as_str() {
@@ -1069,7 +1069,7 @@ pub async fn upsert_http_request(
};
let trimmed_name = r.name.trim();
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
@@ -1109,8 +1109,8 @@ pub async fn upsert_http_request(
.execute(&db)
.await?;
match get_http_request(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_http_request(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -1165,15 +1165,15 @@ pub async fn get_http_request(
}
pub async fn delete_http_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<HttpRequest, sqlx::Error> {
let req = get_http_request(mgr, id).await?;
let req = get_http_request(window, id).await?;
// DB deletes will cascade but this will delete the files
delete_all_http_responses(mgr, id).await?;
delete_all_http_responses(window, id).await?;
let db = get_db(mgr).await;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
DELETE FROM http_requests
@@ -1184,12 +1184,12 @@ pub async fn delete_http_request(
.execute(&db)
.await;
emit_deleted_model(mgr, req)
emit_deleted_model(window, req)
}
#[allow(clippy::too_many_arguments)]
pub async fn create_http_response(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
request_id: &str,
elapsed: i64,
elapsed_headers: i64,
@@ -1202,10 +1202,10 @@ pub async fn create_http_response(
version: Option<&str>,
remote_addr: Option<&str>,
) -> Result<HttpResponse, sqlx::Error> {
let req = get_http_request(mgr, request_id).await?;
let req = get_http_request(window, request_id).await?;
let id = generate_id(Some("rp"));
let headers_json = Json(headers);
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
INSERT INTO http_responses (
@@ -1231,14 +1231,14 @@ pub async fn create_http_response(
.execute(&db)
.await?;
match get_http_response(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_http_response(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
pub async fn cancel_pending_grpc_connections(mgr: &impl Manager<Wry>) -> Result<(), sqlx::Error> {
let db = get_db(mgr).await;
pub async fn cancel_pending_grpc_connections(app: &AppHandle) -> Result<(), sqlx::Error> {
let db = get_db(app).await;
sqlx::query!(
r#"
UPDATE grpc_connections
@@ -1251,8 +1251,8 @@ pub async fn cancel_pending_grpc_connections(mgr: &impl Manager<Wry>) -> Result<
Ok(())
}
pub async fn cancel_pending_responses(mgr: &impl Manager<Wry>) -> Result<(), sqlx::Error> {
let db = get_db(mgr).await;
pub async fn cancel_pending_responses(app: &AppHandle) -> Result<(), sqlx::Error> {
let db = get_db(app).await;
sqlx::query!(
r#"
UPDATE http_responses
@@ -1266,18 +1266,18 @@ pub async fn cancel_pending_responses(mgr: &impl Manager<Wry>) -> Result<(), sql
}
pub async fn update_response_if_id(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
response: &HttpResponse,
) -> Result<HttpResponse, sqlx::Error> {
if response.id.is_empty() {
Ok(response.clone())
} else {
update_response(mgr, response).await
update_response(window, response).await
}
}
pub async fn upsert_workspace(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
workspace: Workspace,
) -> Result<Workspace, sqlx::Error> {
let id = match workspace.id.as_str() {
@@ -1286,7 +1286,7 @@ pub async fn upsert_workspace(
};
let trimmed_name = workspace.name.trim();
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
INSERT INTO workspaces (
@@ -1314,17 +1314,17 @@ pub async fn upsert_workspace(
.execute(&db)
.await?;
match get_workspace(mgr, &id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_workspace(window, &id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
pub async fn update_response(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
response: &HttpResponse,
) -> Result<HttpResponse, sqlx::Error> {
let db = get_db(mgr).await;
let db = get_db(window).await;
sqlx::query!(
r#"
UPDATE http_responses SET (
@@ -1348,8 +1348,8 @@ pub async fn update_response(
.execute(&db)
.await?;
match get_http_response(mgr, &response.id).await {
Ok(m) => Ok(emit_upserted_model(mgr, m)),
match get_http_response(window, &response.id).await {
Ok(m) => Ok(emit_upserted_model(window, m)),
Err(e) => Err(e),
}
}
@@ -1427,12 +1427,12 @@ pub async fn list_responses_by_workspace_id(
}
pub async fn delete_grpc_request(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<GrpcRequest, sqlx::Error> {
let req = get_grpc_request(mgr, id).await?;
let req = get_grpc_request(window, id).await?;
let db = get_db(mgr).await;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
DELETE FROM grpc_requests
@@ -1443,16 +1443,16 @@ pub async fn delete_grpc_request(
.execute(&db)
.await;
emit_deleted_model(mgr, req)
emit_deleted_model(window, req)
}
pub async fn delete_grpc_connection(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<GrpcConnection, sqlx::Error> {
let resp = get_grpc_connection(mgr, id).await?;
let resp = get_grpc_connection(window, id).await?;
let db = get_db(mgr).await;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
DELETE FROM grpc_connections
@@ -1463,14 +1463,14 @@ pub async fn delete_grpc_connection(
.execute(&db)
.await;
emit_deleted_model(mgr, resp)
emit_deleted_model(window, resp)
}
pub async fn delete_http_response(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
id: &str,
) -> Result<HttpResponse, sqlx::Error> {
let resp = get_http_response(mgr, id).await?;
let resp = get_http_response(window, id).await?;
// Delete the body file if it exists
if let Some(p) = resp.body_path.clone() {
@@ -1479,7 +1479,7 @@ pub async fn delete_http_response(
};
}
let db = get_db(mgr).await;
let db = get_db(window).await;
let _ = sqlx::query!(
r#"
DELETE FROM http_responses
@@ -1490,25 +1490,25 @@ pub async fn delete_http_response(
.execute(&db)
.await;
emit_deleted_model(mgr, resp)
emit_deleted_model(window, resp)
}
pub async fn delete_all_grpc_connections(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
request_id: &str,
) -> Result<(), sqlx::Error> {
for r in list_grpc_connections(mgr, request_id).await? {
delete_grpc_connection(mgr, &r.id).await?;
for r in list_grpc_connections(window, request_id).await? {
delete_grpc_connection(window, &r.id).await?;
}
Ok(())
}
pub async fn delete_all_http_responses(
mgr: &impl Manager<Wry>,
window: &WebviewWindow,
request_id: &str,
) -> Result<(), sqlx::Error> {
for r in list_responses(mgr, request_id, None).await? {
delete_http_response(mgr, &r.id).await?;
for r in list_responses(window, request_id, None).await? {
delete_http_response(window, &r.id).await?;
}
Ok(())
}
@@ -1541,9 +1541,10 @@ pub struct WorkspaceExportResources {
}
pub async fn get_workspace_export_resources(
app_handle: &AppHandle,
window: &WebviewWindow,
workspace_ids: Vec<&str>,
) -> WorkspaceExport {
let app_handle = window.app_handle();
let mut data = WorkspaceExport {
yaak_version: app_handle.package_info().version.clone().to_string(),
yaak_schema: 2,
@@ -1559,42 +1560,58 @@ pub async fn get_workspace_export_resources(
for workspace_id in workspace_ids {
data.resources.workspaces.push(
get_workspace(app_handle, workspace_id)
get_workspace(window, workspace_id)
.await
.expect("Failed to get workspace"),
);
data.resources.environments.append(
&mut list_environments(app_handle, workspace_id)
&mut list_environments(window, workspace_id)
.await
.expect("Failed to get environments"),
);
data.resources.folders.append(
&mut list_folders(app_handle, workspace_id)
&mut list_folders(window, workspace_id)
.await
.expect("Failed to get folders"),
);
data.resources.http_requests.append(
&mut list_http_requests(app_handle, workspace_id)
&mut list_http_requests(window, workspace_id)
.await
.expect("Failed to get http requests"),
);
data.resources.grpc_requests.append(
&mut list_grpc_requests(app_handle, workspace_id)
&mut list_grpc_requests(window, workspace_id)
.await
.expect("Failed to get grpc requests"),
);
}
return data;
}
fn emit_upserted_model<S: Serialize + Clone>(mgr: &impl Manager<Wry>, model: S) -> S {
mgr.emit_all("upserted_model", model.clone()).unwrap();
#[derive(Clone, Serialize)]
#[serde(default, rename_all = "camelCase")]
struct ModelPayload<M: Serialize + Clone> {
pub model: M,
pub window_label: String,
}
fn emit_upserted_model<M: Serialize + Clone>(window: &WebviewWindow, model: M) -> M {
let payload = ModelPayload{
model: model.clone(),
window_label: window.label().to_string(),
};
window.emit("upserted_model", payload).unwrap();
model
}
fn emit_deleted_model<S: Serialize + Clone, E>(mgr: &impl Manager<Wry>, model: S) -> Result<S, E> {
mgr.emit_all("deleted_model", model.clone()).unwrap();
fn emit_deleted_model<M: Serialize + Clone, E>(window: &WebviewWindow, model: M) -> Result<M, E> {
let payload = ModelPayload{
model: model.clone(),
window_label: window.label().to_string(),
};
window.emit("deleted_model", payload).unwrap();
Ok(model)
}

15
src-tauri/src/plugin.rs
View File

@@ -10,7 +10,8 @@ use boa_runtime::Console;
use log::{debug, error};
use serde::{Deserialize, Serialize};
use serde_json::json;
use tauri::AppHandle;
use tauri::{AppHandle, Manager};
use tauri::path::BaseDirectory;
use crate::models::{WorkspaceExportResources};
@@ -51,7 +52,7 @@ pub async fn run_plugin_import(
app_handle: &AppHandle,
plugin_name: &str,
file_path: &str,
) -> Option<ImportResult> {
) -> Result<Option<ImportResult>, String> {
let file = fs::read_to_string(file_path)
.unwrap_or_else(|_| panic!("Unable to read file {}", file_path));
let file_contents = file.as_str();
@@ -63,12 +64,12 @@ pub async fn run_plugin_import(
);
if result_json.is_null() {
return None;
return Ok(None);
}
let resources: ImportResult =
serde_json::from_value(result_json).expect("failed to parse result json");
Some(resources)
serde_json::from_value(result_json).map_err(|e| e.to_string())?;
Ok(Some(resources))
}
fn run_plugin(
@@ -78,8 +79,8 @@ fn run_plugin(
js_args: &[JsValue],
) -> serde_json::Value {
let plugin_dir = app_handle
.path_resolver()
.resolve_resource("plugins")
.path()
.resolve("plugins", BaseDirectory::Resource)
.expect("failed to resolve plugin directory resource")
.join(plugin_name);
let plugin_index_file = plugin_dir.join("index.mjs");

5
src-tauri/src/render.rs
View File

@@ -1,6 +1,7 @@
use crate::models::{Environment, Workspace};
use std::collections::HashMap;
use tauri::regex::Regex;
use regex::Regex;
pub fn render(template: &str, workspace: &Workspace, environment: Option<&Environment>) -> String {
let mut map = HashMap::new();
@@ -24,7 +25,7 @@ pub fn render(template: &str, workspace: &Workspace, environment: Option<&Enviro
Regex::new(r"\$\{\[\s*([^]\s]+)\s*]}")
.expect("Failed to create regex")
.replace_all(template, |caps: &tauri::regex::Captures| {
.replace_all(template, |caps: &regex::Captures| {
let key = caps.get(1).unwrap().as_str();
map.get(key).unwrap_or(&"")
})

54
src-tauri/src/updates.rs
View File

@@ -1,8 +1,9 @@
use std::time::SystemTime;
use log::info;
use tauri::api::dialog;
use tauri::{updater, AppHandle, Window};
use tauri::{AppHandle};
use tauri_plugin_dialog::DialogExt;
use tauri_plugin_updater::UpdaterExt;
use crate::is_dev;
@@ -29,7 +30,7 @@ impl YaakUpdater {
&mut self,
app_handle: &AppHandle,
mode: UpdateMode,
) -> Result<bool, updater::Error> {
) -> Result<bool, tauri_plugin_updater::Error> {
self.last_update_check = SystemTime::now();
let update_mode = get_update_mode_str(mode);
@@ -44,49 +45,48 @@ impl YaakUpdater {
}
match app_handle
.updater()
.updater_builder()
.header("X-Update-Mode", update_mode)?
.build()?
.check()
.await
{
Ok(update) => {
Ok(Some(update)) => {
let h = app_handle.clone();
dialog::ask(
None::<&Window>,
"Update Available",
format!(
app_handle
.dialog()
.message(format!(
"{} is available. Would you like to download and install it now?",
update.latest_version()
),
|confirmed| {
update.version
))
.title("Update Available")
.show(|confirmed| {
if !confirmed {
return;
}
tauri::async_runtime::spawn(async move {
match update.download_and_install().await {
match update.download_and_install(|_, _| {}, || {}).await {
Ok(_) => {
if dialog::blocking::ask(
None::<&Window>,
"Update Installed",
"Would you like to restart the app?",
) {
if h
.dialog()
.message("Would you like to restart the app?")
.title("Update Installed")
.blocking_show()
{
h.restart();
}
}
Err(e) => {
dialog::message(
None::<&Window>,
"Update Failed",
format!("The update failed to install: {}", e),
);
h
.dialog()
.message(format!("The update failed to install: {}", e));
}
}
});
},
);
});
Ok(true)
}
Err(updater::Error::UpToDate) => Ok(false),
Ok(None) => Ok(false),
Err(e) => Err(e),
}
}
@@ -94,7 +94,7 @@ impl YaakUpdater {
&mut self,
app_handle: &AppHandle,
mode: UpdateMode,
) -> Result<bool, updater::Error> {
) -> Result<bool, tauri_plugin_updater::Error> {
let ignore_check =
self.last_update_check.elapsed().unwrap().as_secs() < MAX_UPDATE_CHECK_SECONDS;
if ignore_check {

4
src-tauri/src/window_ext.rs
View File

@@ -1,4 +1,4 @@
use tauri::{Runtime, Window};
use tauri::{WebviewWindow};
const TRAFFIC_LIGHT_OFFSET_X: f64 = 13.0;
const TRAFFIC_LIGHT_OFFSET_Y: f64 = 18.0;
@@ -7,7 +7,7 @@ pub trait TrafficLightWindowExt {
fn position_traffic_lights(&self);
}
impl<R: Runtime> TrafficLightWindowExt for Window<R> {
impl TrafficLightWindowExt for WebviewWindow {
#[cfg(not(target_os = "macos"))]
fn position_traffic_lights(&self) {
// No-op on other platforms

270
src-tauri/src/window_menu.rs
View File

@@ -1,140 +1,142 @@
use tauri::{AboutMetadata, CustomMenuItem, Menu, MenuItem, Submenu};
use crate::is_dev;
use tauri::menu::{
AboutMetadata, Menu, MenuItemBuilder, PredefinedMenuItem, Submenu, HELP_SUBMENU_ID,
WINDOW_SUBMENU_ID,
};
pub use tauri::AppHandle;
use tauri::Wry;
pub fn os_default(#[allow(unused)] app_name: &str) -> Menu {
let mut menu = Menu::new();
#[cfg(target_os = "macos")]
{
menu = menu.add_submenu(Submenu::new(
app_name,
Menu::new()
.add_native_item(MenuItem::About(
app_name.to_string(),
AboutMetadata::default(),
))
.add_native_item(MenuItem::Separator)
.add_item(
CustomMenuItem::new("toggle_settings".to_string(), "Settings")
.accelerator("CmdOrCtrl+,"),
)
.add_native_item(MenuItem::Separator)
.add_native_item(MenuItem::Services)
.add_native_item(MenuItem::Separator)
.add_native_item(MenuItem::Hide)
.add_native_item(MenuItem::HideOthers)
.add_native_item(MenuItem::ShowAll)
.add_native_item(MenuItem::Separator)
.add_native_item(MenuItem::Quit),
));
}
pub fn app_menu(app_handle: &AppHandle) -> tauri::Result<Menu<Wry>> {
let pkg_info = app_handle.package_info();
let config = app_handle.config();
let about_metadata = AboutMetadata {
name: Some(pkg_info.name.clone()),
version: Some(pkg_info.version.to_string()),
copyright: config.bundle.copyright.clone(),
authors: config.bundle.publisher.clone().map(|p| vec![p]),
..Default::default()
};
let mut file_menu = Menu::new();
file_menu = file_menu.add_native_item(MenuItem::CloseWindow);
#[cfg(not(target_os = "macos"))]
{
file_menu = file_menu.add_native_item(MenuItem::Quit);
}
menu = menu.add_submenu(Submenu::new("File", file_menu));
let window_menu = Submenu::with_id_and_items(
app_handle,
WINDOW_SUBMENU_ID,
"Window",
true,
&[
&PredefinedMenuItem::minimize(app_handle, None)?,
&PredefinedMenuItem::maximize(app_handle, None)?,
#[cfg(target_os = "macos")]
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::close_window(app_handle, None)?,
],
)?;
#[cfg(not(target_os = "linux"))]
let mut edit_menu = Menu::new();
#[cfg(target_os = "macos")]
{
edit_menu = edit_menu.add_native_item(MenuItem::Undo);
edit_menu = edit_menu.add_native_item(MenuItem::Redo);
edit_menu = edit_menu.add_native_item(MenuItem::Separator);
}
#[cfg(not(target_os = "linux"))]
{
edit_menu = edit_menu.add_native_item(MenuItem::Cut);
edit_menu = edit_menu.add_native_item(MenuItem::Copy);
edit_menu = edit_menu.add_native_item(MenuItem::Paste);
}
#[cfg(target_os = "macos")]
{
edit_menu = edit_menu.add_native_item(MenuItem::SelectAll);
}
#[cfg(not(target_os = "linux"))]
{
menu = menu.add_submenu(Submenu::new("Edit", edit_menu));
}
let mut view_menu = Menu::new();
#[cfg(target_os = "macos")]
{
view_menu = view_menu
.add_native_item(MenuItem::EnterFullScreen)
.add_native_item(MenuItem::Separator);
}
view_menu = view_menu
.add_item(
CustomMenuItem::new("zoom_reset".to_string(), "Zoom to Actual Size")
.accelerator("CmdOrCtrl+0"),
)
.add_item(
CustomMenuItem::new("zoom_in".to_string(), "Zoom In").accelerator("CmdOrCtrl+Plus"),
)
.add_item(
CustomMenuItem::new("zoom_out".to_string(), "Zoom Out").accelerator("CmdOrCtrl+-"),
);
// .add_native_item(MenuItem::Separator)
// .add_item(
// CustomMenuItem::new("toggle_sidebar".to_string(), "Toggle Sidebar")
// .accelerator("CmdOrCtrl+b"),
// )
// .add_item(
// CustomMenuItem::new("focus_sidebar".to_string(), "Focus Sidebar")
// .accelerator("CmdOrCtrl+1"),
// )
// .add_item(
// CustomMenuItem::new("toggle_settings".to_string(), "Toggle Settings")
// .accelerator("CmdOrCtrl+,"),
// )
// .add_item(
// CustomMenuItem::new("focus_url".to_string(), "Focus URL").accelerator("CmdOrCtrl+l"),
// );
menu = menu.add_submenu(Submenu::new("View", view_menu));
let help_menu = Submenu::with_id_and_items(
app_handle,
HELP_SUBMENU_ID,
"Help",
true,
&[
#[cfg(not(target_os = "macos"))]
&PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
#[cfg(target_os = "macos")]
&MenuItemBuilder::with_id("open_feedback".to_string(), "Give Feedback")
.build(app_handle)?,
],
)?;
let mut window_menu = Menu::new();
window_menu = window_menu.add_native_item(MenuItem::Minimize);
#[cfg(target_os = "macos")]
{
window_menu = window_menu.add_native_item(MenuItem::Zoom);
window_menu = window_menu.add_native_item(MenuItem::Separator);
}
window_menu = window_menu.add_native_item(MenuItem::CloseWindow);
menu = menu.add_submenu(Submenu::new("Window", window_menu));
let menu = Menu::with_items(
app_handle,
&[
#[cfg(target_os = "macos")]
&Submenu::with_items(
app_handle,
pkg_info.name.clone(),
true,
&[
&PredefinedMenuItem::about(app_handle, None, Some(about_metadata))?,
&PredefinedMenuItem::separator(app_handle)?,
&MenuItemBuilder::with_id("settings".to_string(), "Settings")
.accelerator("CmdOrCtrl+,")
.build(app_handle)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::services(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::hide(app_handle, None)?,
&PredefinedMenuItem::hide_others(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::quit(app_handle, None)?,
],
)?,
#[cfg(not(any(
target_os = "linux",
target_os = "dragonfly",
target_os = "freebsd",
target_os = "netbsd",
target_os = "openbsd"
)))]
&Submenu::with_items(
app_handle,
"File",
true,
&[
&PredefinedMenuItem::close_window(app_handle, None)?,
#[cfg(not(target_os = "macos"))]
&PredefinedMenuItem::quit(app_handle, None)?,
],
)?,
&Submenu::with_items(
app_handle,
"Edit",
true,
&[
&PredefinedMenuItem::undo(app_handle, None)?,
&PredefinedMenuItem::redo(app_handle, None)?,
&PredefinedMenuItem::separator(app_handle)?,
&PredefinedMenuItem::cut(app_handle, None)?,
&PredefinedMenuItem::copy(app_handle, None)?,
&PredefinedMenuItem::paste(app_handle, None)?,
&PredefinedMenuItem::select_all(app_handle, None)?,
],
)?,
&Submenu::with_items(
app_handle,
"View",
true,
&[
#[cfg(target_os = "macos")]
&PredefinedMenuItem::fullscreen(app_handle, None)?,
#[cfg(target_os = "macos")]
&PredefinedMenuItem::separator(app_handle)?,
&MenuItemBuilder::with_id("zoom_reset".to_string(), "Zoom to Actual Size")
.accelerator("CmdOrCtrl+0")
.build(app_handle)?,
&MenuItemBuilder::with_id("zoom_in".to_string(), "Zoom In")
.accelerator("CmdOrCtrl+=")
.build(app_handle)?,
&MenuItemBuilder::with_id("zoom_out".to_string(), "Zoom Out")
.accelerator("CmdOrCtrl+-")
.build(app_handle)?,
],
)?,
&window_menu,
&help_menu,
#[cfg(dev)]
&Submenu::with_items(
app_handle,
"Develop",
true,
&[
&MenuItemBuilder::with_id("refresh".to_string(), "Refresh")
.accelerator("CmdOrCtrl+Shift+r")
.build(app_handle)?,
&MenuItemBuilder::with_id("toggle_devtools".to_string(), "Open Devtools")
.accelerator("CmdOrCtrl+Option+i")
.build(app_handle)?,
],
)?,
],
)?;
// menu = menu.add_submenu(Submenu::new(
// "Workspace",
// Menu::new()
// .add_item(
// CustomMenuItem::new("send_request".to_string(), "Send Request")
// .accelerator("CmdOrCtrl+r"),
// )
// .add_item(
// CustomMenuItem::new("new_request".to_string(), "New Request")
// .accelerator("CmdOrCtrl+n"),
// )
// .add_item(
// CustomMenuItem::new("duplicate_request".to_string(), "Duplicate Request")
// .accelerator("CmdOrCtrl+d"),
// ),
// ));
if is_dev() {
menu = menu.add_submenu(Submenu::new(
"Developer",
Menu::new()
.add_item(
CustomMenuItem::new("refresh".to_string(), "Refresh")
.accelerator("CmdOrCtrl + Shift + r"),
)
.add_item(
CustomMenuItem::new("toggle_devtools".to_string(), "Open Devtools")
.accelerator("CmdOrCtrl + Option + i"),
),
));
}
menu
Ok(menu)
}