starred/yaak-mountain-loop
1
0
Fork 0
mirror of https://github.com/mountain-loop/yaak.git synced 2026-04-21 08:11:24 +02:00
Code Issues 8 Packages Projects Releases 10 Wiki Activity

Generalized frontend model store (#193)

Browse Source
This commit is contained in:
Gregory Schier
2025-03-31 11:56:17 -07:00
committed by GitHub
parent ce885c3551
commit f1757ae427
201 changed files with 2185 additions and 2865 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src-tauri/yaak-models/src/queries/cookie_jars.rs
View File

@@ -9,7 +9,18 @@ impl<'a> DbContext<'a> {
}
pub fn list_cookie_jars(&self, workspace_id: &str) -> Result<Vec<CookieJar>> {
self.find_many(CookieJarIden::WorkspaceId, workspace_id, None)
let mut cookie_jars = self.find_many(CookieJarIden::WorkspaceId, workspace_id, None)?;
if cookie_jars.is_empty() {
let jar = CookieJar {
name: "Default".to_string(),
workspace_id: workspace_id.to_string(),
..Default::default()
};
cookie_jars.push(self.upsert_cookie_jar(&jar, &UpdateSource::Background)?);
}
Ok(cookie_jars)
}
pub fn delete_cookie_jar(

59
src-tauri/yaak-models/src/queries/environments.rs
View File

@@ -1,11 +1,8 @@
use crate::error::Result;
use crate::models::{Environment, EnvironmentIden, UpsertModelInfo};
use crate::util::UpdateSource;
use log::info;
use sea_query::ColumnRef::Asterisk;
use sea_query::{Cond, Expr, Query, SqliteQueryBuilder};
use sea_query_rusqlite::RusqliteBinder;
use crate::db_context::DbContext;
use crate::error::Error::GenericError;
use crate::error::Result;
use crate::models::{Environment, EnvironmentIden};
use crate::util::UpdateSource;
impl<'a> DbContext<'a> {
pub fn get_environment(&self, id: &str) -> Result<Environment> {
@@ -13,42 +10,38 @@ impl<'a> DbContext<'a> {
}
pub fn get_base_environment(&self, workspace_id: &str) -> Result<Environment> {
let (sql, params) = Query::select()
.from(EnvironmentIden::Table)
.column(Asterisk)
.cond_where(
Cond::all()
.add(Expr::col(EnvironmentIden::WorkspaceId).eq(workspace_id))
.add(Expr::col(EnvironmentIden::EnvironmentId).is_null()),
)
.build_rusqlite(SqliteQueryBuilder);
let mut stmt = self.conn.prepare(sql.as_str())?;
Ok(stmt.query_row(&*params.as_params(), Environment::from_row)?)
// Will create base environment if it doesn't exist
let environments = self.list_environments(workspace_id)?;
let base_environment = environments
.into_iter()
.find(|e| e.environment_id == None && e.workspace_id == workspace_id)
.ok_or(GenericError(format!("No base environment found for {workspace_id}")))?;
Ok(base_environment)
}
pub fn ensure_base_environment(&self, workspace_id: &str) -> Result<()> {
let environments = self.list_environments(workspace_id)?;
pub fn list_environments(&self, workspace_id: &str) -> Result<Vec<Environment>> {
let mut environments =
self.find_many::<Environment>(EnvironmentIden::WorkspaceId, workspace_id, None)?;
let base_environment = environments
.iter()
.find(|e| e.environment_id == None && e.workspace_id == workspace_id);
if let None = base_environment {
info!("Creating base environment for {workspace_id}");
self.upsert_environment(
environments.push(self.upsert_environment(
&Environment {
workspace_id: workspace_id.to_string(),
environment_id: None,
name: "Global Variables".to_string(),
..Default::default()
},
&UpdateSource::Background,
)?;
)?);
}
Ok(())
}
pub fn list_environments(&self, workspace_id: &str) -> Result<Vec<Environment>> {
self.find_many(EnvironmentIden::WorkspaceId, workspace_id, None)
Ok(environments)
}
pub fn delete_environment(
@@ -69,6 +62,16 @@ impl<'a> DbContext<'a> {
self.delete_environment(&environment, source)
}
pub fn duplicate_environment(
&self,
environment: &Environment,
source: &UpdateSource,
) -> Result<Environment> {
let mut environment = environment.clone();
environment.id = "".to_string();
self.upsert(&environment, source)
}
pub fn upsert_environment(
&self,
environment: &Environment,

73
src-tauri/yaak-models/src/queries/folders.rs
View File

@@ -1,3 +1,4 @@
use crate::connection_or_tx::ConnectionOrTx;
use crate::db_context::DbContext;
use crate::error::Result;
use crate::models::{
@@ -16,20 +17,29 @@ impl<'a> DbContext<'a> {
}
pub fn delete_folder(&self, folder: &Folder, source: &UpdateSource) -> Result<Folder> {
for folder in self.find_many::<Folder>(FolderIden::FolderId, &folder.id, None)? {
match self.conn {
ConnectionOrTx::Connection(_) => {}
ConnectionOrTx::Transaction(_) => {}
}
let fid = &folder.id;
for m in self.find_many::<HttpRequest>(HttpRequestIden::FolderId, fid, None)? {
self.delete_http_request(&m, source)?;
}
for m in self.find_many::<GrpcRequest>(GrpcRequestIden::FolderId, fid, None)? {
self.delete_grpc_request(&m, source)?;
}
for m in self.find_many::<WebsocketRequest>(WebsocketRequestIden::FolderId, fid, None)? {
self.delete_websocket_request(&m, source)?;
}
// Recurse down into child folders
for folder in self.find_many::<Folder>(FolderIden::FolderId, fid, None)? {
self.delete_folder(&folder, source)?;
}
for request in self.find_many::<HttpRequest>(HttpRequestIden::FolderId, &folder.id, None)? {
self.delete_http_request(&request, source)?;
}
for request in self.find_many::<GrpcRequest>(GrpcRequestIden::FolderId, &folder.id, None)? {
self.delete_grpc_request(&request, source)?;
}
for request in
self.find_many::<WebsocketRequest>(WebsocketRequestIden::FolderId, &folder.id, None)?
{
self.delete_websocket_request(&request, source)?;
}
self.delete(folder, source)
}
@@ -43,22 +53,7 @@ impl<'a> DbContext<'a> {
}
pub fn duplicate_folder(&self, src_folder: &Folder, source: &UpdateSource) -> Result<Folder> {
let workspace_id = src_folder.workspace_id.as_str();
let http_requests = self
.find_many::<HttpRequest>(HttpRequestIden::WorkspaceId, workspace_id, None)?
.into_iter()
.filter(|m| m.folder_id.as_ref() == Some(&src_folder.id));
let grpc_requests = self
.find_many::<GrpcRequest>(GrpcRequestIden::WorkspaceId, workspace_id, None)?
.into_iter()
.filter(|m| m.folder_id.as_ref() == Some(&src_folder.id));
let folders = self
.find_many::<Folder>(FolderIden::WorkspaceId, workspace_id, None)?
.into_iter()
.filter(|m| m.folder_id.as_ref() == Some(&src_folder.id));
let fid = &src_folder.id;
let new_folder = self.upsert_folder(
&Folder {
@@ -69,29 +64,40 @@ impl<'a> DbContext<'a> {
source,
)?;
for m in http_requests {
for m in self.find_many::<HttpRequest>(HttpRequestIden::FolderId, fid, None)? {
self.upsert_http_request(
&HttpRequest {
id: "".into(),
folder_id: Some(new_folder.id.clone()),
sort_priority: m.sort_priority + 0.001,
..m
},
source,
)?;
}
for m in grpc_requests {
for m in self.find_many::<WebsocketRequest>(WebsocketRequestIden::FolderId, fid, None)? {
self.upsert_websocket_request(
&WebsocketRequest {
id: "".into(),
folder_id: Some(new_folder.id.clone()),
..m
},
source,
)?;
}
for m in self.find_many::<GrpcRequest>(GrpcRequestIden::FolderId, fid, None)? {
self.upsert_grpc_request(
&GrpcRequest {
id: "".into(),
folder_id: Some(new_folder.id.clone()),
sort_priority: m.sort_priority + 0.001,
..m
},
source,
)?;
}
for m in folders {
for m in self.find_many::<Folder>(FolderIden::FolderId, fid, None)? {
// Recurse down
self.duplicate_folder(
&Folder {
@@ -101,6 +107,7 @@ impl<'a> DbContext<'a> {
source,
)?;
}
Ok(new_folder)
}
}

14
src-tauri/yaak-models/src/queries/grpc_connections.rs
View File

@@ -1,11 +1,11 @@
use crate::db_context::DbContext;
use crate::error::Result;
use crate::models::{GrpcConnection, GrpcConnectionIden, GrpcConnectionState};
use crate::queries::MAX_HISTORY_ITEMS;
use crate::util::UpdateSource;
use log::debug;
use sea_query::{Expr, Query, SqliteQueryBuilder};
use sea_query_rusqlite::RusqliteBinder;
use crate::db_context::DbContext;
use crate::queries::MAX_HISTORY_ITEMS;
impl<'a> DbContext<'a> {
pub fn get_grpc_connection(&self, id: &str) -> Result<GrpcConnection> {
@@ -29,7 +29,7 @@ impl<'a> DbContext<'a> {
workspace_id: &str,
source: &UpdateSource,
) -> Result<()> {
for m in self.list_grpc_connections_for_workspace(workspace_id, None)? {
for m in self.list_grpc_connections(workspace_id)? {
self.delete(&m, source)?;
}
Ok(())
@@ -60,12 +60,8 @@ impl<'a> DbContext<'a> {
self.find_many(GrpcConnectionIden::RequestId, request_id, limit)
}
pub fn list_grpc_connections_for_workspace(
&self,
workspace_id: &str,
limit: Option<u64>,
) -> Result<Vec<GrpcConnection>> {
self.find_many(GrpcConnectionIden::WorkspaceId, workspace_id, limit)
pub fn list_grpc_connections(&self, workspace_id: &str) -> Result<Vec<GrpcConnection>> {
self.find_many(GrpcConnectionIden::WorkspaceId, workspace_id, None)
}
pub fn cancel_pending_grpc_connections(&self) -> Result<()> {

2
src-tauri/yaak-models/src/queries/http_responses.rs
View File

@@ -21,7 +21,7 @@ impl<'a> DbContext<'a> {
self.find_many(HttpResponseIden::RequestId, request_id, limit)
}
pub fn list_http_responses_for_workspace(
pub fn list_http_responses(
&self,
workspace_id: &str,
limit: Option<u64>,

67
src-tauri/yaak-models/src/queries/key_values.rs
View File

@@ -1,20 +1,19 @@
use crate::db_context::DbContext;
use crate::error::Result;
use crate::models::{KeyValue, KeyValueIden};
use crate::util::{ModelChangeEvent, ModelPayload, UpdateSource};
use crate::models::{KeyValue, KeyValueIden, UpsertModelInfo};
use crate::util::UpdateSource;
use log::error;
use sea_query::Keyword::CurrentTimestamp;
use sea_query::{Asterisk, Cond, Expr, OnConflict, Query, SqliteQueryBuilder};
use sea_query::{Asterisk, Cond, Expr, Query, SqliteQueryBuilder};
use sea_query_rusqlite::RusqliteBinder;
impl<'a> DbContext<'a> {
pub fn list_key_values_raw(&self) -> Result<Vec<KeyValue>> {
pub fn list_key_values(&self) -> Result<Vec<KeyValue>> {
let (sql, params) = Query::select()
.from(KeyValueIden::Table)
.column(Asterisk)
.build_rusqlite(SqliteQueryBuilder);
let mut stmt = self.conn.prepare(sql.as_str())?;
let items = stmt.query_map(&*params.as_params(), |row| row.try_into())?;
let items = stmt.query_map(&*params.as_params(), KeyValue::from_row)?;
Ok(items.map(|v| v.unwrap()).collect())
}
@@ -60,7 +59,7 @@ impl<'a> DbContext<'a> {
.add(Expr::col(KeyValueIden::Key).eq(key)),
)
.build_rusqlite(SqliteQueryBuilder);
self.conn.resolve().query_row(sql.as_str(), &*params.as_params(), |row| row.try_into()).ok()
self.conn.resolve().query_row(sql.as_str(), &*params.as_params(), KeyValue::from_row).ok()
}
pub fn set_key_value_string(
@@ -125,43 +124,7 @@ impl<'a> DbContext<'a> {
key_value: &KeyValue,
source: &UpdateSource,
) -> Result<KeyValue> {
let (sql, params) = Query::insert()
.into_table(KeyValueIden::Table)
.columns([
KeyValueIden::CreatedAt,
KeyValueIden::UpdatedAt,
KeyValueIden::Namespace,
KeyValueIden::Key,
KeyValueIden::Value,
])
.values_panic([
CurrentTimestamp.into(),
CurrentTimestamp.into(),
key_value.namespace.clone().into(),
key_value.key.clone().into(),
key_value.value.clone().into(),
])
.on_conflict(
OnConflict::new()
.update_columns([KeyValueIden::UpdatedAt, KeyValueIden::Value])
.to_owned(),
)
.returning_all()
.build_rusqlite(SqliteQueryBuilder);
let mut stmt = self.conn.prepare(sql.as_str()).expect("Failed to prepare KeyValue upsert");
let m: KeyValue = stmt
.query_row(&*params.as_params(), |row| row.try_into())
.expect("Failed to upsert KeyValue");
let payload = ModelPayload {
model: m.clone().into(),
update_source: source.clone(),
change: ModelChangeEvent::Upsert,
};
self.tx.try_send(payload).unwrap();
Ok(m)
self.upsert(key_value, source)
}
pub fn delete_key_value(
@@ -175,21 +138,7 @@ impl<'a> DbContext<'a> {
Some(m) => m,
};
let (sql, params) = Query::delete()
.from_table(KeyValueIden::Table)
.cond_where(
Cond::all()
.add(Expr::col(KeyValueIden::Namespace).eq(namespace))
.add(Expr::col(KeyValueIden::Key).eq(key)),
)
.build_rusqlite(SqliteQueryBuilder);
self.conn.execute(sql.as_str(), &*params.as_params())?;
let payload = ModelPayload {
model: kv.clone().into(),
update_source: source.clone(),
change: ModelChangeEvent::Delete,
};
self.tx.try_send(payload).unwrap();
self.delete(&kv, source)?;
Ok(())
}
}

2
src-tauri/yaak-models/src/queries/mod.rs
View File

@@ -18,4 +18,4 @@ mod websocket_requests;
mod workspace_metas;
mod workspaces;
const MAX_HISTORY_ITEMS: usize = 20;
const MAX_HISTORY_ITEMS: usize = 20;

31
src-tauri/yaak-models/src/queries/settings.rs
View File

@@ -1,24 +1,35 @@
use crate::db_context::DbContext;
use crate::error::Result;
use crate::models::{Settings, SettingsIden};
use crate::models::{EditorKeymap, Settings, SettingsIden};
use crate::util::UpdateSource;
impl<'a> DbContext<'a> {
pub fn get_or_create_settings(&self, source: &UpdateSource) -> Settings {
pub fn get_settings(&self) -> Settings {
let id = "default".to_string();
if let Some(s) = self.find_optional::<Settings>(SettingsIden::Id, &id) {
return s;
};
self.upsert(
&Settings {
id,
..Default::default()
},
source,
)
.expect("Failed to upsert settings")
let settings = Settings {
model: "settings".to_string(),
id,
created_at: Default::default(),
updated_at: Default::default(),
appearance: "system".to_string(),
editor_font_size: 13,
editor_keymap: EditorKeymap::Default,
editor_soft_wrap: true,
interface_font_size: 15,
interface_scale: 1.0,
open_workspace_new_window: None,
proxy: None,
theme_dark: "yaak-dark".to_string(),
theme_light: "yaak-light".to_string(),
update_channel: "stable".to_string(),
};
self.upsert(&settings, &UpdateSource::Background).expect("Failed to upsert settings")
}
pub fn upsert_settings(&self, settings: &Settings, source: &UpdateSource) -> Result<Settings> {

4
src-tauri/yaak-models/src/queries/websocket_connections.rs
View File

@@ -29,14 +29,14 @@ impl<'a> DbContext<'a> {
workspace_id: &str,
source: &UpdateSource,
) -> Result<()> {
let responses = self.list_websocket_connections_for_workspace(workspace_id)?;
let responses = self.list_websocket_connections(workspace_id)?;
for m in responses {
self.delete(&m, source)?;
}
Ok(())
}
pub fn list_websocket_connections_for_workspace(
pub fn list_websocket_connections(
&self,
workspace_id: &str,
) -> Result<Vec<WebsocketConnection>> {

27
src-tauri/yaak-models/src/queries/workspace_metas.rs
View File

@@ -1,25 +1,40 @@
use crate::db_context::DbContext;
use crate::error::Result;
use crate::models::{Workspace, WorkspaceMeta, WorkspaceMetaIden};
use crate::models::{WorkspaceMeta, WorkspaceMetaIden};
use crate::util::UpdateSource;
impl<'a> DbContext<'a> {
pub fn get_workspace_meta(&self, workspace: &Workspace) -> Option<WorkspaceMeta> {
self.find_optional(WorkspaceMetaIden::WorkspaceId, &workspace.id)
pub fn get_workspace_meta(&self, workspace_id: &str) -> Option<WorkspaceMeta> {
self.find_optional(WorkspaceMetaIden::WorkspaceId, workspace_id)
}
pub fn list_workspace_metas(&self, workspace_id: &str) -> Result<Vec<WorkspaceMeta>> {
let mut workspace_metas =
self.find_many(WorkspaceMetaIden::WorkspaceId, workspace_id, None)?;
if workspace_metas.is_empty() {
let wm = WorkspaceMeta {
workspace_id: workspace_id.to_string(),
..Default::default()
};
workspace_metas.push(self.upsert_workspace_meta(&wm, &UpdateSource::Background)?)
}
Ok(workspace_metas)
}
pub fn get_or_create_workspace_meta(
&self,
workspace: &Workspace,
workspace_id: &str,
source: &UpdateSource,
) -> Result<WorkspaceMeta> {
let workspace_meta = self.get_workspace_meta(workspace);
let workspace_meta = self.get_workspace_meta(workspace_id);
if let Some(workspace_meta) = workspace_meta {
return Ok(workspace_meta);
}
let workspace_meta = WorkspaceMeta {
workspace_id: workspace.to_owned().id,
workspace_id: workspace_id.to_string(),
..Default::default()
};

46
src-tauri/yaak-models/src/queries/workspaces.rs
View File

@@ -12,7 +12,21 @@ impl<'a> DbContext<'a> {
}
pub fn list_workspaces(&self) -> Result<Vec<Workspace>> {
self.find_all()
let mut workspaces = self.find_all()?;
if workspaces.is_empty() {
workspaces.push(self.upsert_workspace(
&Workspace {
name: "Yaak".to_string(),
setting_follow_redirects: true,
setting_validate_certificates: true,
..Default::default()
},
&UpdateSource::Background,
)?)
}
Ok(workspaces)
}
pub fn delete_workspace(
@@ -20,24 +34,24 @@ impl<'a> DbContext<'a> {
workspace: &Workspace,
source: &UpdateSource,
) -> Result<Workspace> {
for m in self.find_many::<HttpRequest>(HttpRequestIden::WorkspaceId, &workspace.id, None)? {
self.delete_http_request(&m, source)?;
}
for m in self.find_many::<GrpcRequest>(GrpcRequestIden::WorkspaceId, &workspace.id, None)? {
self.delete_grpc_request(&m, source)?;
}
for m in
self.find_many::<WebsocketRequest>(WebsocketRequestIden::FolderId, &workspace.id, None)?
{
self.delete_websocket_request(&m, source)?;
}
for folder in self.find_many::<Folder>(FolderIden::WorkspaceId, &workspace.id, None)? {
self.delete_folder(&folder, source)?;
}
for request in
self.find_many::<HttpRequest>(HttpRequestIden::WorkspaceId, &workspace.id, None)?
{
self.delete_http_request(&request, source)?;
}
for request in
self.find_many::<GrpcRequest>(GrpcRequestIden::WorkspaceId, &workspace.id, None)?
{
self.delete_grpc_request(&request, source)?;
}
for request in
self.find_many::<WebsocketRequest>(WebsocketRequestIden::FolderId, &workspace.id, None)?
{
self.delete_websocket_request(&request, source)?;
}
self.delete(workspace, source)
}