Database access refactor (#190)

2026-04-24 01:28:35 +02:00 · 2025-03-25 08:35:10 -07:00
parent 445c30f3a9
commit 1d37d46130
72 changed files with 4895 additions and 4702 deletions
--- a/src-tauri/yaak-models/Cargo.toml
+++ b/src-tauri/yaak-models/Cargo.toml
@@ -1,5 +1,6 @@
 [package]
 name = "yaak-models"
+links = "yaak-models"
 version = "0.1.0"
 edition = "2021"
 publish = false
@@ -18,4 +19,8 @@ serde_json = "1.0.122"
 sqlx = { version = "0.8.0", default-features = false, features = ["migrate", "sqlite", "runtime-tokio-rustls"] }
 tauri = { workspace = true }
 thiserror = "2.0.11"
+tokio = "1.43.0"
 ts-rs = { workspace = true, features = ["chrono-impl", "serde-json-impl"] }
+
+[build-dependencies]
+tauri-plugin = { workspace = true, features = ["build"] }
--- a/src-tauri/yaak-models/bindings/gen_models.ts
+++ b/src-tauri/yaak-models/bindings/gen_models.ts
@@ -1,6 +1,6 @@
 // This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.

-export type AnyModel = CookieJar | Environment | Folder | GrpcConnection | GrpcEvent | GrpcRequest | HttpRequest | HttpResponse | Plugin | Settings | KeyValue | Workspace | WorkspaceMeta | WebsocketConnection | WebsocketEvent | WebsocketRequest;
+export type AnyModel = CookieJar | Environment | Folder | GrpcConnection | GrpcEvent | GrpcRequest | HttpRequest | HttpResponse | KeyValue | Plugin | Settings | SyncState | WebsocketConnection | WebsocketEvent | WebsocketRequest | Workspace | WorkspaceMeta;

 export type Cookie = { raw_cookie: string, domain: CookieDomain, expires: CookieExpires, path: [string, boolean], };

@@ -44,7 +44,9 @@ export type HttpUrlParameter = { enabled?: boolean, name: string, value: string,

 export type KeyValue = { model: "key_value", createdAt: string, updatedAt: string, key: string, namespace: string, value: string, };

-export type ModelPayload = { model: AnyModel, updateSource: UpdateSource, };
+export type ModelChangeEvent = { "type": "upsert" } | { "type": "delete" };
+
+export type ModelPayload = { model: AnyModel, updateSource: UpdateSource, change: ModelChangeEvent, };

 export type Plugin = { model: "plugin", id: string, createdAt: string, updatedAt: string, checkedAt: string | null, directory: string, enabled: boolean, url: string | null, };

@@ -56,8 +58,6 @@ export type ProxySettingAuth = { user: string, password: string, };

 export type Settings = { model: "settings", id: string, createdAt: string, updatedAt: string, appearance: string, editorFontSize: number, editorSoftWrap: boolean, interfaceFontSize: number, interfaceScale: number, openWorkspaceNewWindow: boolean | null, proxy: ProxySetting | null, theme: string, themeDark: string, themeLight: string, updateChannel: string, editorKeymap: EditorKeymap, };

-export type SyncHistory = { model: "sync_history", id: string, workspaceId: string, createdAt: string, states: Array<SyncState>, checksum: string, relPath: string, syncDir: string, };
-
 export type SyncState = { model: "sync_state", id: string, workspaceId: string, createdAt: string, updatedAt: string, flushedAt: string, modelId: string, checksum: string, relPath: string, syncDir: string, };

 export type UpdateSource = { "type": "sync" } | { "type": "window", label: string, } | { "type": "plugin" } | { "type": "background" } | { "type": "import" };
--- a/src-tauri/yaak-models/build.rs
+++ b/src-tauri/yaak-models/build.rs
@@ -0,0 +1,5 @@
+const COMMANDS: &[&str] = &["upsert", "delete"];
+
+fn main() {
+    tauri_plugin::Builder::new(COMMANDS).build();
+}
--- a/src-tauri/yaak-models/permissions/autogenerated/commands/delete.toml
+++ b/src-tauri/yaak-models/permissions/autogenerated/commands/delete.toml
@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-delete"
+description = "Enables the delete command without any pre-configured scope."
+commands.allow = ["delete"]
+
+[[permission]]
+identifier = "deny-delete"
+description = "Denies the delete command without any pre-configured scope."
+commands.deny = ["delete"]
--- a/src-tauri/yaak-models/permissions/autogenerated/commands/delete_model.toml
+++ b/src-tauri/yaak-models/permissions/autogenerated/commands/delete_model.toml
@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-delete-model"
+description = "Enables the delete_model command without any pre-configured scope."
+commands.allow = ["delete_model"]
+
+[[permission]]
+identifier = "deny-delete-model"
+description = "Denies the delete_model command without any pre-configured scope."
+commands.deny = ["delete_model"]
--- a/src-tauri/yaak-models/permissions/autogenerated/commands/upsert.toml
+++ b/src-tauri/yaak-models/permissions/autogenerated/commands/upsert.toml
@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-upsert"
+description = "Enables the upsert command without any pre-configured scope."
+commands.allow = ["upsert"]
+
+[[permission]]
+identifier = "deny-upsert"
+description = "Denies the upsert command without any pre-configured scope."
+commands.deny = ["upsert"]
--- a/src-tauri/yaak-models/permissions/autogenerated/commands/upsert_model.toml
+++ b/src-tauri/yaak-models/permissions/autogenerated/commands/upsert_model.toml
@@ -0,0 +1,13 @@
+# Automatically generated - DO NOT EDIT!
+
+"$schema" = "../../schemas/schema.json"
+
+[[permission]]
+identifier = "allow-upsert-model"
+description = "Enables the upsert_model command without any pre-configured scope."
+commands.allow = ["upsert_model"]
+
+[[permission]]
+identifier = "deny-upsert-model"
+description = "Denies the upsert_model command without any pre-configured scope."
+commands.deny = ["upsert_model"]
--- a/src-tauri/yaak-models/permissions/autogenerated/reference.md
+++ b/src-tauri/yaak-models/permissions/autogenerated/reference.md
@@ -0,0 +1,120 @@
+## Default Permission
+
+Default permissions for the plugin
+
+- `allow-upsert`
+- `allow-delete`
+
+## Permission Table
+
+<table>
+<tr>
+<th>Identifier</th>
+<th>Description</th>
+</tr>
+
+
+<tr>
+<td>
+
+`yaak-models:allow-delete`
+
+</td>
+<td>
+
+Enables the delete command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:deny-delete`
+
+</td>
+<td>
+
+Denies the delete command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:allow-delete-model`
+
+</td>
+<td>
+
+Enables the delete_model command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:deny-delete-model`
+
+</td>
+<td>
+
+Denies the delete_model command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:allow-upsert`
+
+</td>
+<td>
+
+Enables the upsert command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:deny-upsert`
+
+</td>
+<td>
+
+Denies the upsert command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:allow-upsert-model`
+
+</td>
+<td>
+
+Enables the upsert_model command without any pre-configured scope.
+
+</td>
+</tr>
+
+<tr>
+<td>
+
+`yaak-models:deny-upsert-model`
+
+</td>
+<td>
+
+Denies the upsert_model command without any pre-configured scope.
+
+</td>
+</tr>
+</table>
--- a/src-tauri/yaak-models/permissions/default.toml
+++ b/src-tauri/yaak-models/permissions/default.toml
@@ -0,0 +1,6 @@
+[default]
+description = "Default permissions for the plugin"
+permissions = [
+    "allow-upsert",
+    "allow-delete",
+]
--- a/src-tauri/yaak-models/permissions/schemas/schema.json
+++ b/src-tauri/yaak-models/permissions/schemas/schema.json
@@ -0,0 +1,345 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "PermissionFile",
+  "description": "Permission file that can define a default permission, a set of permissions or a list of inlined permissions.",
+  "type": "object",
+  "properties": {
+    "default": {
+      "description": "The default permission set for the plugin",
+      "anyOf": [
+        {
+          "$ref": "#/definitions/DefaultPermission"
+        },
+        {
+          "type": "null"
+        }
+      ]
+    },
+    "set": {
+      "description": "A list of permissions sets defined",
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/PermissionSet"
+      }
+    },
+    "permission": {
+      "description": "A list of inlined permissions",
+      "default": [],
+      "type": "array",
+      "items": {
+        "$ref": "#/definitions/Permission"
+      }
+    }
+  },
+  "definitions": {
+    "DefaultPermission": {
+      "description": "The default permission set of the plugin.\n\nWorks similarly to a permission with the \"default\" identifier.",
+      "type": "object",
+      "required": [
+        "permissions"
+      ],
+      "properties": {
+        "version": {
+          "description": "The version of the permission.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 1.0
+        },
+        "description": {
+          "description": "Human-readable description of what the permission does. Tauri convention is to use `<h4>` headings in markdown content for Tauri documentation generation purposes.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "permissions": {
+          "description": "All permissions this set contains.",
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "PermissionSet": {
+      "description": "A set of direct permissions grouped together under a new name.",
+      "type": "object",
+      "required": [
+        "description",
+        "identifier",
+        "permissions"
+      ],
+      "properties": {
+        "identifier": {
+          "description": "A unique identifier for the permission.",
+          "type": "string"
+        },
+        "description": {
+          "description": "Human-readable description of what the permission does.",
+          "type": "string"
+        },
+        "permissions": {
+          "description": "All permissions this set contains.",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/PermissionKind"
+          }
+        }
+      }
+    },
+    "Permission": {
+      "description": "Descriptions of explicit privileges of commands.\n\nIt can enable commands to be accessible in the frontend of the application.\n\nIf the scope is defined it can be used to fine grain control the access of individual or multiple commands.",
+      "type": "object",
+      "required": [
+        "identifier"
+      ],
+      "properties": {
+        "version": {
+          "description": "The version of the permission.",
+          "type": [
+            "integer",
+            "null"
+          ],
+          "format": "uint64",
+          "minimum": 1.0
+        },
+        "identifier": {
+          "description": "A unique identifier for the permission.",
+          "type": "string"
+        },
+        "description": {
+          "description": "Human-readable description of what the permission does. Tauri internal convention is to use `<h4>` headings in markdown content for Tauri documentation generation purposes.",
+          "type": [
+            "string",
+            "null"
+          ]
+        },
+        "commands": {
+          "description": "Allowed or denied commands when using this permission.",
+          "default": {
+            "allow": [],
+            "deny": []
+          },
+          "allOf": [
+            {
+              "$ref": "#/definitions/Commands"
+            }
+          ]
+        },
+        "scope": {
+          "description": "Allowed or denied scoped when using this permission.",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Scopes"
+            }
+          ]
+        },
+        "platforms": {
+          "description": "Target platforms this permission applies. By default all platforms are affected by this permission.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/Target"
+          }
+        }
+      }
+    },
+    "Commands": {
+      "description": "Allowed and denied commands inside a permission.\n\nIf two commands clash inside of `allow` and `deny`, it should be denied by default.",
+      "type": "object",
+      "properties": {
+        "allow": {
+          "description": "Allowed command.",
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "deny": {
+          "description": "Denied command, which takes priority.",
+          "default": [],
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "Scopes": {
+      "description": "An argument for fine grained behavior control of Tauri commands.\n\nIt can be of any serde serializable type and is used to allow or prevent certain actions inside a Tauri command. The configured scope is passed to the command and will be enforced by the command implementation.\n\n## Example\n\n```json { \"allow\": [{ \"path\": \"$HOME/**\" }], \"deny\": [{ \"path\": \"$HOME/secret.txt\" }] } ```",
+      "type": "object",
+      "properties": {
+        "allow": {
+          "description": "Data that defines what is allowed by the scope.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/Value"
+          }
+        },
+        "deny": {
+          "description": "Data that defines what is denied by the scope. This should be prioritized by validation logic.",
+          "type": [
+            "array",
+            "null"
+          ],
+          "items": {
+            "$ref": "#/definitions/Value"
+          }
+        }
+      }
+    },
+    "Value": {
+      "description": "All supported ACL values.",
+      "anyOf": [
+        {
+          "description": "Represents a null JSON value.",
+          "type": "null"
+        },
+        {
+          "description": "Represents a [`bool`].",
+          "type": "boolean"
+        },
+        {
+          "description": "Represents a valid ACL [`Number`].",
+          "allOf": [
+            {
+              "$ref": "#/definitions/Number"
+            }
+          ]
+        },
+        {
+          "description": "Represents a [`String`].",
+          "type": "string"
+        },
+        {
+          "description": "Represents a list of other [`Value`]s.",
+          "type": "array",
+          "items": {
+            "$ref": "#/definitions/Value"
+          }
+        },
+        {
+          "description": "Represents a map of [`String`] keys to [`Value`]s.",
+          "type": "object",
+          "additionalProperties": {
+            "$ref": "#/definitions/Value"
+          }
+        }
+      ]
+    },
+    "Number": {
+      "description": "A valid ACL number.",
+      "anyOf": [
+        {
+          "description": "Represents an [`i64`].",
+          "type": "integer",
+          "format": "int64"
+        },
+        {
+          "description": "Represents a [`f64`].",
+          "type": "number",
+          "format": "double"
+        }
+      ]
+    },
+    "Target": {
+      "description": "Platform target.",
+      "oneOf": [
+        {
+          "description": "MacOS.",
+          "type": "string",
+          "enum": [
+            "macOS"
+          ]
+        },
+        {
+          "description": "Windows.",
+          "type": "string",
+          "enum": [
+            "windows"
+          ]
+        },
+        {
+          "description": "Linux.",
+          "type": "string",
+          "enum": [
+            "linux"
+          ]
+        },
+        {
+          "description": "Android.",
+          "type": "string",
+          "enum": [
+            "android"
+          ]
+        },
+        {
+          "description": "iOS.",
+          "type": "string",
+          "enum": [
+            "iOS"
+          ]
+        }
+      ]
+    },
+    "PermissionKind": {
+      "type": "string",
+      "oneOf": [
+        {
+          "description": "Enables the delete command without any pre-configured scope.",
+          "type": "string",
+          "const": "allow-delete"
+        },
+        {
+          "description": "Denies the delete command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-delete"
+        },
+        {
+          "description": "Enables the delete_model command without any pre-configured scope.",
+          "type": "string",
+          "const": "allow-delete-model"
+        },
+        {
+          "description": "Denies the delete_model command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-delete-model"
+        },
+        {
+          "description": "Enables the upsert command without any pre-configured scope.",
+          "type": "string",
+          "const": "allow-upsert"
+        },
+        {
+          "description": "Denies the upsert command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-upsert"
+        },
+        {
+          "description": "Enables the upsert_model command without any pre-configured scope.",
+          "type": "string",
+          "const": "allow-upsert-model"
+        },
+        {
+          "description": "Denies the upsert_model command without any pre-configured scope.",
+          "type": "string",
+          "const": "deny-upsert-model"
+        },
+        {
+          "description": "Default permissions for the plugin",
+          "type": "string",
+          "const": "default"
+        }
+      ]
+    }
+  }
+}
--- a/src-tauri/yaak-models/src/commands.rs
+++ b/src-tauri/yaak-models/src/commands.rs
@@ -0,0 +1,24 @@
+use crate::error::Result;
+use crate::manager::QueryManagerExt;
+use crate::models::AnyModel;
+use crate::queries_legacy::UpdateSource;
+use tauri::{Runtime, WebviewWindow};
+
+#[tauri::command]
+pub(crate) async fn upsert<R: Runtime>(
+    window: WebviewWindow<R>,
+    model: AnyModel,
+) -> Result<String> {
+    let queries = window.queries().connect().await?;
+    let id = match model {
+        AnyModel::HttpRequest(r) => queries.upsert(&r, &UpdateSource::from_window(&window))?.id,
+        _ => todo!(),
+    };
+
+    Ok(id)
+}
+
+#[tauri::command]
+pub(crate) fn delete() -> Result<()> {
+    Ok(())
+}
--- a/src-tauri/yaak-models/src/error.rs
+++ b/src-tauri/yaak-models/src/error.rs
@@ -1,3 +1,4 @@
+use serde::{Serialize, Serializer};
 use thiserror::Error;

 #[derive(Error, Debug)]
@@ -11,11 +12,29 @@ pub enum Error {
    #[error("JSON error: {0}")]
    JsonError(#[from] serde_json::Error),

-    #[error("Model not found {0}")]
+    #[error("Model not found: {0}")]
    ModelNotFound(String),

+    #[error("Model serialization error: {0}")]
+    ModelSerializationError(String),
+
+    #[error("Model error: {0}")]
+    GenericError(String),
+    
+    #[error("Row not found")]
+    RowNotFound,
+
    #[error("unknown error")]
    Unknown,
 }

+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>;
--- a/src-tauri/yaak-models/src/lib.rs
+++ b/src-tauri/yaak-models/src/lib.rs
@@ -1,7 +1,98 @@
+use crate::commands::{delete, upsert};
+use crate::manager::QueryManager;
+use crate::queries_legacy::ModelChangeEvent;
+use log::info;
+use r2d2::Pool;
+use r2d2_sqlite::SqliteConnectionManager;
+use sqlx::migrate::Migrator;
+use sqlx::sqlite::SqliteConnectOptions;
+use sqlx::SqlitePool;
+use std::fs::create_dir_all;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::time::Duration;
+use tauri::async_runtime::Mutex;
+use tauri::path::BaseDirectory;
+use tauri::plugin::TauriPlugin;
+use tauri::{generate_handler, AppHandle, Emitter, Manager, Runtime};
+use tokio::sync::mpsc;
+
+mod commands;
+
 pub mod error;
+pub mod manager;
 pub mod models;
 pub mod queries;
-
-pub mod plugin;
+pub mod queries_legacy;
 pub mod render;
-pub mod manager;
+
+pub struct SqliteConnection(pub Mutex<Pool<SqliteConnectionManager>>);
+
+impl SqliteConnection {
+    pub(crate) fn new(pool: Pool<SqliteConnectionManager>) -> Self {
+        Self(Mutex::new(pool))
+    }
+}
+
+pub fn init<R: Runtime>() -> TauriPlugin<R> {
+    tauri::plugin::Builder::new("yaak_models")
+        .invoke_handler(generate_handler![upsert, delete])
+        .setup(|app_handle, _api| {
+            let app_path = app_handle.path().app_data_dir().unwrap();
+            create_dir_all(app_path.clone()).expect("Problem creating App directory!");
+
+            let db_file_path = app_path.join("db.sqlite");
+
+            {
+                let db_file_path = db_file_path.clone();
+                tauri::async_runtime::block_on(async move {
+                    must_migrate_db(app_handle.app_handle(), &db_file_path).await;
+                });
+            };
+
+            let manager = SqliteConnectionManager::file(db_file_path);
+            let pool = Pool::builder()
+                .max_size(100) // Up from 10 (just in case)
+                .connection_timeout(Duration::from_secs(10)) // Down from 30
+                .build(manager)
+                .unwrap();
+
+            app_handle.manage(SqliteConnection::new(pool.clone()));
+
+            {
+                let (tx, mut rx) = mpsc::channel(128);
+                app_handle.manage(QueryManager::new(pool, tx));
+                let app_handle = app_handle.clone();
+                tauri::async_runtime::spawn(async move {
+                    while let Some(p) = rx.recv().await {
+                        let name = match p.change {
+                            ModelChangeEvent::Upsert => "upserted_model",
+                            ModelChangeEvent::Delete => "deleted_model",
+                        };
+                        app_handle.emit(name, p).unwrap();
+                    }
+                });
+            }
+
+            Ok(())
+        })
+        .build()
+}
+
+async fn must_migrate_db<R: Runtime>(app_handle: &AppHandle<R>, sqlite_file_path: &PathBuf) {
+    info!("Connecting to database at {sqlite_file_path:?}");
+    let sqlite_file_path = sqlite_file_path.to_str().unwrap().to_string();
+    let opts = SqliteConnectOptions::from_str(&sqlite_file_path).unwrap().create_if_missing(true);
+    let pool = SqlitePool::connect_with(opts).await.expect("Failed to connect to database");
+    let p = app_handle
+        .path()
+        .resolve("migrations", BaseDirectory::Resource)
+        .expect("failed to resolve resource");
+
+    info!("Running database migrations from: {}", p.to_string_lossy());
+    let mut m = Migrator::new(p).await.expect("Failed to load migrations");
+    m.set_ignore_missing(true); // So we can roll back versions and not crash
+    m.run(&pool).await.expect("Failed to run migrations");
+
+    info!("Database migrations complete");
+}
--- a/src-tauri/yaak-models/src/manager.rs
+++ b/src-tauri/yaak-models/src/manager.rs
@@ -1,40 +1,108 @@
 use crate::error::Result;
-use crate::models::{Workspace, WorkspaceIden};
-use crate::plugin::SqliteConnection;
+use crate::queries_legacy::ModelPayload;
 use r2d2::{Pool, PooledConnection};
 use r2d2_sqlite::SqliteConnectionManager;
-use rusqlite::Connection;
-use sea_query::{Asterisk, Order, Query, SqliteQueryBuilder};
-use sea_query_rusqlite::RusqliteBinder;
-use std::future::Future;
-use std::ops::Deref;
-use tauri::{AppHandle, Manager, Runtime};
+use rusqlite::{Connection, Statement, ToSql, Transaction, TransactionBehavior};
+use std::sync::Arc;
+use tauri::{Manager, Runtime};
+use tokio::sync::{mpsc, Mutex};

-pub struct QueryManager {
-    pool: Pool<SqliteConnectionManager>,
+pub trait QueryManagerExt<'a, R> {
+    fn queries(&'a self) -> &'a QueryManager;
 }

-pub trait DBConnection {
-    fn connect(
-        &self,
-    ) -> impl Future<Output = Result<PooledConnection<SqliteConnectionManager>>> + Send;
-}
-
-impl<R: Runtime> DBConnection for AppHandle<R> {
-    async fn connect(&self) -> Result<PooledConnection<SqliteConnectionManager>> {
-        let dbm = &*self.state::<SqliteConnection>();
-        let db = dbm.0.lock().await.get()?;
-        Ok(db)
+impl<'a, R: Runtime, T: Manager<R>> QueryManagerExt<'a, R> for T {
+    fn queries(&'a self) -> &'a QueryManager {
+        let qm = self.state::<QueryManager>();
+        qm.inner()
    }
 }

-pub async fn list_workspaces<T: Deref<Target = Connection>>(c: &T) -> Result<Vec<Workspace>> {
-    let (sql, params) = Query::select()
-        .from(WorkspaceIden::Table)
-        .column(Asterisk)
-        .order_by(WorkspaceIden::Name, Order::Asc)
-        .build_rusqlite(SqliteQueryBuilder);
-    let mut stmt = c.prepare(sql.as_str())?;
-    let items = stmt.query_map(&*params.as_params(), |row| row.try_into())?;
-    Ok(items.map(|v| v.unwrap()).collect())
+#[derive(Clone)]
+pub struct QueryManager {
+    pool: Arc<Mutex<Pool<SqliteConnectionManager>>>,
+    events_tx: mpsc::Sender<ModelPayload>,
+}
+
+impl QueryManager {
+    pub(crate) fn new(
+        pool: Pool<SqliteConnectionManager>,
+        events_tx: mpsc::Sender<ModelPayload>,
+    ) -> Self {
+        QueryManager {
+            pool: Arc::new(Mutex::new(pool)),
+            events_tx,
+        }
+    }
+
+    pub async fn connect(&self) -> Result<DbContext> {
+        let conn = self.pool.lock().await.get()?;
+        Ok(DbContext {
+            tx: self.events_tx.clone(),
+            conn: ConnectionOrTx::Connection(conn),
+        })
+    }
+
+    pub async fn with_conn<F, T>(&self, func: F) -> Result<T>
+    where
+        F: FnOnce(&DbContext) -> Result<T>,
+    {
+        let conn = self.pool.lock().await.get()?;
+        let db_context = DbContext {
+            tx: self.events_tx.clone(),
+            conn: ConnectionOrTx::Connection(conn),
+        };
+        func(&db_context)
+    }
+
+    pub async fn with_tx<F, T>(&self, func: F) -> Result<T>
+    where
+        F: FnOnce(&DbContext) -> Result<T>,
+    {
+        let mut conn = self.pool.lock().await.get()?;
+        let tx = conn.transaction_with_behavior(TransactionBehavior::Immediate)?;
+
+        let db_context = DbContext {
+            tx: self.events_tx.clone(),
+            conn: ConnectionOrTx::Transaction(&tx),
+        };
+
+        match func(&db_context) {
+            Ok(val) => {
+                tx.commit()?;
+                Ok(val)
+            }
+            Err(e) => {
+                tx.rollback()?;
+                Err(e)
+            }
+        }
+    }
+}
+
+pub enum ConnectionOrTx<'a> {
+    Connection(PooledConnection<SqliteConnectionManager>),
+    Transaction(&'a Transaction<'a>),
+}
+
+impl<'a> ConnectionOrTx<'a> {
+    pub(crate) fn resolve(&self) -> &Connection {
+        match self {
+            ConnectionOrTx::Connection(c) => c,
+            ConnectionOrTx::Transaction(c) => c,
+        }
+    }
+
+    pub(crate) fn prepare(&self, sql: &str) -> rusqlite::Result<Statement<'_>> {
+        self.resolve().prepare(sql)
+    }
+
+    pub(crate) fn execute(&self, sql: &str, params: &[&dyn ToSql]) -> rusqlite::Result<usize> {
+        self.resolve().execute(sql, params)
+    }
+}
+
+pub struct DbContext<'a> {
+    pub(crate) tx: mpsc::Sender<ModelPayload>,
+    pub(crate) conn: ConnectionOrTx<'a>,
 }
--- a/src-tauri/yaak-models/src/models.rs
+++ b/src-tauri/yaak-models/src/models.rs
--- a/src-tauri/yaak-models/src/plugin.rs
+++ b/src-tauri/yaak-models/src/plugin.rs
@@ -1,81 +0,0 @@
-use log::info;
-use r2d2::Pool;
-use r2d2_sqlite::SqliteConnectionManager;
-use serde::Deserialize;
-use sqlx::migrate::Migrator;
-use sqlx::sqlite::SqliteConnectOptions;
-use sqlx::SqlitePool;
-use std::fs::create_dir_all;
-use std::path::PathBuf;
-use std::str::FromStr;
-use std::time::Duration;
-use tauri::async_runtime::Mutex;
-use tauri::path::BaseDirectory;
-use tauri::plugin::TauriPlugin;
-use tauri::{plugin, AppHandle, Manager, Runtime};
-
-pub struct SqliteConnection(pub Mutex<Pool<SqliteConnectionManager>>);
-
-#[derive(Default, Deserialize)]
-pub struct PluginConfig {
-    // Nothing yet (will be configurable in tauri.conf.json
-}
-
-/// Tauri SQL plugin builder.
-#[derive(Default)]
-pub struct Builder {
-    // Nothing Yet
-}
-
-impl Builder {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn build<R: Runtime>(&self) -> TauriPlugin<R, Option<PluginConfig>> {
-        plugin::Builder::<R, Option<PluginConfig>>::new("yaak_models")
-            .setup(|app, _api| {
-                let app_path = app.path().app_data_dir().unwrap();
-                create_dir_all(app_path.clone()).expect("Problem creating App directory!");
-
-                let db_file_path = app_path.join("db.sqlite");
-
-                {
-                    let db_file_path = db_file_path.clone();
-                    tauri::async_runtime::block_on(async move {
-                        must_migrate_db(app.app_handle(), &db_file_path).await;
-                    });
-                };
-
-                let manager = SqliteConnectionManager::file(db_file_path);
-                let pool = Pool::builder()
-                    .max_size(100) // Up from 10 (just in case)
-                    .connection_timeout(Duration::from_secs(10)) // Down from 30
-                    .build(manager)
-                    .unwrap();
-
-                app.manage(SqliteConnection(Mutex::new(pool)));
-
-                Ok(())
-            })
-            .build()
-    }
-}
-
-async fn must_migrate_db<R: Runtime>(app_handle: &AppHandle<R>, sqlite_file_path: &PathBuf) {
-    info!("Connecting to database at {sqlite_file_path:?}");
-    let sqlite_file_path = sqlite_file_path.to_str().unwrap().to_string();
-    let opts = SqliteConnectOptions::from_str(&sqlite_file_path).unwrap().create_if_missing(true);
-    let pool = SqlitePool::connect_with(opts).await.expect("Failed to connect to database");
-    let p = app_handle
-        .path()
-        .resolve("migrations", BaseDirectory::Resource)
-        .expect("failed to resolve resource");
-
-    info!("Running database migrations from: {}", p.to_string_lossy());
-    let mut m = Migrator::new(p).await.expect("Failed to load migrations");
-    m.set_ignore_missing(true); // So we can roll back versions and not crash
-    m.run(&pool).await.expect("Failed to run migrations");
-
-    info!("Database migrations complete");
-}
--- a/src-tauri/yaak-models/src/queries.rs
+++ b/src-tauri/yaak-models/src/queries.rs
--- a/src-tauri/yaak-models/src/queries/base.rs
+++ b/src-tauri/yaak-models/src/queries/base.rs
@@ -0,0 +1,169 @@
+use crate::error::Error::RowNotFound;
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{AnyModel, ModelType, UpsertModelInfo};
+use crate::queries_legacy::{generate_model_id, ModelChangeEvent, ModelPayload, UpdateSource};
+use rusqlite::OptionalExtension;
+use sea_query::{
+    Asterisk, Expr, IntoColumnRef, IntoIden, IntoTableRef, OnConflict, Query, SimpleExpr,
+    SqliteQueryBuilder,
+};
+use sea_query_rusqlite::RusqliteBinder;
+
+pub(crate) const MAX_HISTORY_ITEMS: usize = 20;
+
+impl<'a> DbContext<'a> {
+    pub(crate) fn find_one<'s, M>(
+        &self,
+        col: impl IntoColumnRef,
+        value: impl Into<SimpleExpr>,
+    ) -> Result<M>
+    where
+        M: Into<AnyModel> + Clone + UpsertModelInfo,
+    {
+        match self.find_optional::<M>(col, value) {
+            Ok(Some(v)) => Ok(v),
+            Ok(None) => Err(RowNotFound),
+            Err(e) => Err(e),
+        }
+    }
+
+    pub fn find_optional<'s, M>(
+        &self,
+        col: impl IntoColumnRef,
+        value: impl Into<SimpleExpr>,
+    ) -> Result<Option<M>>
+    where
+        M: Into<AnyModel> + Clone + UpsertModelInfo,
+    {
+        let (sql, params) = Query::select()
+            .from(M::table_name())
+            .column(Asterisk)
+            .cond_where(Expr::col(col).eq(value))
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.prepare(sql.as_str())?;
+        Ok(stmt.query_row(&*params.as_params(), M::from_row).optional()?)
+    }
+
+    pub fn find_all<'s, M>(&self) -> Result<Vec<M>>
+    where
+        M: Into<AnyModel> + Clone + UpsertModelInfo,
+    {
+        let (sql, params) = Query::select()
+            .from(M::table_name())
+            .column(Asterisk)
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.resolve().prepare(sql.as_str())?;
+        let items = stmt.query_map(&*params.as_params(), M::from_row)?;
+        Ok(items.map(|v| v.unwrap()).collect())
+    }
+
+    pub fn find_many<'s, M>(
+        &self,
+        col: impl IntoColumnRef,
+        value: impl Into<SimpleExpr>,
+        limit: Option<u64>,
+    ) -> Result<Vec<M>>
+    where
+        M: Into<AnyModel> + Clone + UpsertModelInfo,
+    {
+        // TODO: Figure out how to do this conditional builder better
+        let (sql, params) = if let Some(limit) = limit {
+            Query::select()
+                .from(M::table_name())
+                .column(Asterisk)
+                .cond_where(Expr::col(col).eq(value))
+                .limit(limit)
+                .build_rusqlite(SqliteQueryBuilder)
+        } else {
+            Query::select()
+                .from(M::table_name())
+                .column(Asterisk)
+                .cond_where(Expr::col(col).eq(value))
+                .build_rusqlite(SqliteQueryBuilder)
+        };
+
+        let mut stmt = self.conn.resolve().prepare(sql.as_str())?;
+        let items = stmt.query_map(&*params.as_params(), M::from_row)?;
+        Ok(items.map(|v| v.unwrap()).collect())
+    }
+
+    pub fn upsert<M>(&self, model: &M, source: &UpdateSource) -> Result<M>
+    where
+        M: Into<AnyModel> + From<AnyModel> + UpsertModelInfo + Clone,
+    {
+        self.upsert_one(
+            M::table_name(),
+            M::id_column(),
+            model.get_id().as_str(),
+            || generate_model_id(ModelType::TypeEnvironment),
+            model.clone().insert_values(source)?,
+            M::update_columns(),
+            source,
+        )
+    }
+
+    fn upsert_one<M>(
+        &self,
+        table: impl IntoTableRef,
+        id_col: impl IntoIden + Eq + Clone,
+        id_val: &str,
+        gen_id: fn() -> String,
+        other_values: Vec<(impl IntoIden + Eq, impl Into<SimpleExpr>)>,
+        update_columns: Vec<impl IntoIden>,
+        source: &UpdateSource,
+    ) -> Result<M>
+    where
+        M: Into<AnyModel> + From<AnyModel> + UpsertModelInfo + Clone,
+    {
+        let id_iden = id_col.into_iden();
+        let mut column_vec = vec![id_iden.clone()];
+        let mut value_vec = vec![if id_val == "" { gen_id().into() } else { id_val.into() }];
+
+        for (col, val) in other_values {
+            value_vec.push(val.into());
+            column_vec.push(col.into_iden());
+        }
+
+        let on_conflict = OnConflict::column(id_iden).update_columns(update_columns).to_owned();
+        let (sql, params) = Query::insert()
+            .into_table(table)
+            .columns(column_vec)
+            .values_panic(value_vec)
+            .on_conflict(on_conflict)
+            .returning_all()
+            .build_rusqlite(SqliteQueryBuilder);
+
+        let mut stmt = self.conn.resolve().prepare(sql.as_str())?;
+        let m: M = stmt.query_row(&*params.as_params(), |row| M::from_row(row))?;
+
+        let payload = ModelPayload {
+            model: m.clone().into(),
+            update_source: source.clone(),
+            change: ModelChangeEvent::Upsert,
+        };
+        self.tx.try_send(payload).unwrap();
+
+        Ok(m)
+    }
+
+    pub(crate) fn delete<'s, M>(&self, m: &M, update_source: &UpdateSource) -> Result<M>
+    where
+        M: Into<AnyModel> + Clone + UpsertModelInfo,
+    {
+        let (sql, params) = Query::delete()
+            .from_table(M::table_name())
+            .cond_where(Expr::col(M::id_column().into_iden()).eq(m.get_id()))
+            .build_rusqlite(SqliteQueryBuilder);
+        self.conn.execute(sql.as_str(), &*params.as_params())?;
+
+        let payload = ModelPayload {
+            model: m.clone().into(),
+            update_source: update_source.clone(),
+            change: ModelChangeEvent::Delete,
+        };
+
+        self.tx.try_send(payload).unwrap();
+        Ok(m.clone())
+    }
+}
--- a/src-tauri/yaak-models/src/queries/batch.rs
+++ b/src-tauri/yaak-models/src/queries/batch.rs
@@ -0,0 +1,99 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{Environment, Folder, GrpcRequest, HttpRequest, WebsocketRequest, Workspace};
+use crate::queries_legacy::{BatchUpsertResult, UpdateSource};
+use log::info;
+
+impl<'a> DbContext<'a> {
+    pub fn batch_upsert(
+        &self,
+        workspaces: Vec<Workspace>,
+        environments: Vec<Environment>,
+        folders: Vec<Folder>,
+        http_requests: Vec<HttpRequest>,
+        grpc_requests: Vec<GrpcRequest>,
+        websocket_requests: Vec<WebsocketRequest>,
+        source: &UpdateSource,
+    ) -> Result<BatchUpsertResult> {
+        let mut imported_resources = BatchUpsertResult::default();
+
+        if workspaces.len() > 0 {
+            info!("Batch inserting {} workspaces", workspaces.len());
+            for v in workspaces {
+                let x = self.upsert_workspace(&v, source)?;
+                imported_resources.workspaces.push(x.clone());
+            }
+        }
+
+        if environments.len() > 0 {
+            while imported_resources.environments.len() < environments.len() {
+                for v in environments.clone() {
+                    if let Some(id) = v.environment_id.clone() {
+                        let has_parent_to_import =
+                            environments.iter().find(|m| m.id == id).is_some();
+                        let imported_parent =
+                            imported_resources.environments.iter().find(|m| m.id == id);
+                        // If there's also a parent to upsert, wait for that one
+                        if imported_parent.is_none() && has_parent_to_import {
+                            continue;
+                        }
+                    }
+                    if let Some(_) = imported_resources.environments.iter().find(|f| f.id == v.id) {
+                        continue;
+                    }
+                    let x = self.upsert_environment(&v, source)?;
+                    imported_resources.environments.push(x.clone());
+                }
+            }
+            info!("Imported {} environments", imported_resources.environments.len());
+        }
+
+        if folders.len() > 0 {
+            while imported_resources.folders.len() < folders.len() {
+                for v in folders.clone() {
+                    if let Some(id) = v.folder_id.clone() {
+                        let has_parent_to_import = folders.iter().find(|m| m.id == id).is_some();
+                        let imported_parent =
+                            imported_resources.folders.iter().find(|m| m.id == id);
+                        // If there's also a parent to upsert, wait for that one
+                        if imported_parent.is_none() && has_parent_to_import {
+                            continue;
+                        }
+                    }
+                    if let Some(_) = imported_resources.folders.iter().find(|f| f.id == v.id) {
+                        continue;
+                    }
+                    let x = self.upsert_folder(&v, source)?;
+                    imported_resources.folders.push(x.clone());
+                }
+            }
+            info!("Imported {} folders", imported_resources.folders.len());
+        }
+
+        if http_requests.len() > 0 {
+            for v in http_requests {
+                let x = self.upsert(&v, source)?;
+                imported_resources.http_requests.push(x.clone());
+            }
+            info!("Imported {} http_requests", imported_resources.http_requests.len());
+        }
+
+        if grpc_requests.len() > 0 {
+            for v in grpc_requests {
+                let x = self.upsert_grpc_request(&v, source)?;
+                imported_resources.grpc_requests.push(x.clone());
+            }
+            info!("Imported {} grpc_requests", imported_resources.grpc_requests.len());
+        }
+
+        if websocket_requests.len() > 0 {
+            for v in websocket_requests {
+                let x = self.upsert_websocket_request(&v, source)?;
+                imported_resources.websocket_requests.push(x.clone());
+            }
+            info!("Imported {} websocket_requests", imported_resources.websocket_requests.len());
+        }
+
+        Ok(imported_resources)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/cookie_jars.rs
+++ b/src-tauri/yaak-models/src/queries/cookie_jars.rs
@@ -0,0 +1,35 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{CookieJar, CookieJarIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_cookie_jar(&self, id: &str) -> Result<CookieJar> {
+        self.find_one(CookieJarIden::Id, id)
+    }
+
+    pub fn list_cookie_jars(&self, workspace_id: &str) -> Result<Vec<CookieJar>> {
+        self.find_many(CookieJarIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn delete_cookie_jar(
+        &self,
+        cookie_jar: &CookieJar,
+        source: &UpdateSource,
+    ) -> Result<CookieJar> {
+        self.delete(cookie_jar, source)
+    }
+
+    pub fn delete_cookie_jar_by_id(&self, id: &str, source: &UpdateSource) -> Result<CookieJar> {
+        let cookie_jar = self.get_cookie_jar(id)?;
+        self.delete_cookie_jar(&cookie_jar, source)
+    }
+
+    pub fn upsert_cookie_jar(
+        &self,
+        cookie_jar: &CookieJar,
+        source: &UpdateSource,
+    ) -> Result<CookieJar> {
+        self.upsert(cookie_jar, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/environments.rs
+++ b/src-tauri/yaak-models/src/queries/environments.rs
@@ -0,0 +1,79 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{Environment, EnvironmentIden, UpsertModelInfo};
+use crate::queries_legacy::UpdateSource;
+use log::info;
+use sea_query::ColumnRef::Asterisk;
+use sea_query::{Cond, Expr, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+
+impl<'a> DbContext<'a> {
+    pub fn get_environment(&self, id: &str) -> Result<Environment> {
+        self.find_one(EnvironmentIden::Id, id)
+    }
+
+    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)?)
+    }
+
+    pub fn ensure_base_environment(&self, workspace_id: &str) -> Result<()> {
+        let environments = self.list_environments(workspace_id)?;
+        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(
+                &Environment {
+                    workspace_id: workspace_id.to_string(),
+                    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)
+    }
+
+    pub fn delete_environment(
+        &self,
+        environment: &Environment,
+        source: &UpdateSource,
+    ) -> Result<Environment> {
+        for environment in
+            self.find_many::<Environment>(EnvironmentIden::EnvironmentId, &environment.id, None)?
+        {
+            self.delete_environment(&environment, source)?;
+        }
+        self.delete(environment, source)
+    }
+
+    pub fn delete_environment_by_id(&self, id: &str, source: &UpdateSource) -> Result<Environment> {
+        let environment = self.get_environment(id)?;
+        self.delete_environment(&environment, source)
+    }
+
+    pub fn upsert_environment(
+        &self,
+        environment: &Environment,
+        source: &UpdateSource,
+    ) -> Result<Environment> {
+        self.upsert(environment, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/folders.rs
+++ b/src-tauri/yaak-models/src/queries/folders.rs
@@ -0,0 +1,106 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{
+    Folder, FolderIden, GrpcRequest, GrpcRequestIden, HttpRequest, HttpRequestIden,
+    WebsocketRequest, WebsocketRequestIden,
+};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_folder(&self, id: &str) -> Result<Folder> {
+        self.find_one(FolderIden::Id, id)
+    }
+
+    pub fn list_folders(&self, workspace_id: &str) -> Result<Vec<Folder>> {
+        self.find_many(FolderIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn delete_folder(&self, folder: &Folder, source: &UpdateSource) -> Result<Folder> {
+        for folder in self.find_many::<Folder>(FolderIden::FolderId, &folder.id, 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)
+    }
+
+    pub fn delete_folder_by_id(&self, id: &str, source: &UpdateSource) -> Result<Folder> {
+        let folder = self.get_folder(id)?;
+        self.delete_folder(&folder, source)
+    }
+
+    pub fn upsert_folder(&self, folder: &Folder, source: &UpdateSource) -> Result<Folder> {
+        self.upsert(folder, source)
+    }
+
+    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 new_folder = self.upsert_folder(
+            &Folder {
+                id: "".into(),
+                sort_priority: src_folder.sort_priority + 0.001,
+                ..src_folder.clone()
+            },
+            source,
+        )?;
+
+        for m in http_requests {
+            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 {
+            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 {
+            // Recurse down
+            self.duplicate_folder(
+                &Folder {
+                    folder_id: Some(new_folder.id.clone()),
+                    ..m
+                },
+                source,
+            )?;
+        }
+        Ok(new_folder)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/grpc_connections.rs
+++ b/src-tauri/yaak-models/src/queries/grpc_connections.rs
@@ -0,0 +1,98 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{GrpcConnection, GrpcConnectionIden, GrpcConnectionState};
+use crate::queries::base::MAX_HISTORY_ITEMS;
+use crate::queries_legacy::UpdateSource;
+use log::debug;
+use sea_query::{Expr, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+
+impl<'a> DbContext<'a> {
+    pub fn get_grpc_connection(&self, id: &str) -> Result<GrpcConnection> {
+        self.find_one(GrpcConnectionIden::Id, id)
+    }
+
+    pub fn delete_all_grpc_connections_for_request(
+        &self,
+        request_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let responses = self.list_grpc_connections_for_request(request_id, None)?;
+        for m in responses {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn delete_all_grpc_connections_for_workspace(
+        &self,
+        workspace_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        for m in self.list_grpc_connections_for_workspace(workspace_id, None)? {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn delete_grpc_connection(
+        &self,
+        m: &GrpcConnection,
+        source: &UpdateSource,
+    ) -> Result<GrpcConnection> {
+        self.delete(m, source)
+    }
+
+    pub fn delete_grpc_connection_by_id(
+        &self,
+        id: &str,
+        source: &UpdateSource,
+    ) -> Result<GrpcConnection> {
+        let grpc_connection = self.get_grpc_connection(id)?;
+        self.delete_grpc_connection(&grpc_connection, source)
+    }
+
+    pub fn list_grpc_connections_for_request(
+        &self,
+        request_id: &str,
+        limit: Option<u64>,
+    ) -> Result<Vec<GrpcConnection>> {
+        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 cancel_pending_grpc_connections(&self) -> Result<()> {
+        let closed = serde_json::to_value(&GrpcConnectionState::Closed)?;
+        let (sql, params) = Query::update()
+            .table(GrpcConnectionIden::Table)
+            .values([(GrpcConnectionIden::State, closed.as_str().into())])
+            .cond_where(Expr::col(GrpcConnectionIden::State).ne(closed.as_str()))
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.prepare(sql.as_str())?;
+        stmt.execute(&*params.as_params())?;
+        Ok(())
+    }
+
+    pub fn upsert_grpc_connection(
+        &self,
+        grpc_connection: &GrpcConnection,
+        source: &UpdateSource,
+    ) -> Result<GrpcConnection> {
+        let connections =
+            self.list_grpc_connections_for_request(grpc_connection.request_id.as_str(), None)?;
+
+        for m in connections.iter().skip(MAX_HISTORY_ITEMS - 1) {
+            debug!("Deleting old gRPC connection {}", grpc_connection.id);
+            self.delete_grpc_connection(&m, source)?;
+        }
+
+        self.upsert(grpc_connection, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/grpc_events.rs
+++ b/src-tauri/yaak-models/src/queries/grpc_events.rs
@@ -0,0 +1,22 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{GrpcEvent, GrpcEventIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_grpc_events(&self, id: &str) -> Result<GrpcEvent> {
+        self.find_one(GrpcEventIden::Id, id)
+    }
+
+    pub fn list_grpc_events(&self, connection_id: &str) -> Result<Vec<GrpcEvent>> {
+        self.find_many(GrpcEventIden::ConnectionId, connection_id, None)
+    }
+
+    pub fn upsert_grpc_event(
+        &self,
+        grpc_event: &GrpcEvent,
+        source: &UpdateSource,
+    ) -> Result<GrpcEvent> {
+        self.upsert(grpc_event, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/grpc_requests.rs
+++ b/src-tauri/yaak-models/src/queries/grpc_requests.rs
@@ -0,0 +1,51 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{GrpcRequest, GrpcRequestIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_grpc_request(&self, id: &str) -> Result<Option<GrpcRequest>> {
+        self.find_optional(GrpcRequestIden::Id, id)
+    }
+
+    pub fn list_grpc_requests(&self, workspace_id: &str) -> Result<Vec<GrpcRequest>> {
+        self.find_many(GrpcRequestIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn delete_grpc_request(
+        &self,
+        m: &GrpcRequest,
+        source: &UpdateSource,
+    ) -> Result<GrpcRequest> {
+        self.delete_all_grpc_connections_for_request(m.id.as_str(), source)?;
+        self.delete(m, source)
+    }
+
+    pub fn delete_grpc_request_by_id(
+        &self,
+        id: &str,
+        source: &UpdateSource,
+    ) -> Result<GrpcRequest> {
+        let request = self.get_grpc_request(id)?.unwrap();
+        self.delete_grpc_request(&request, source)
+    }
+
+    pub fn duplicate_grpc_request(
+        &self,
+        grpc_request: &GrpcRequest,
+        source: &UpdateSource,
+    ) -> Result<GrpcRequest> {
+        let mut request = grpc_request.clone();
+        request.id = "".to_string();
+        request.sort_priority = request.sort_priority + 0.001;
+        self.upsert(&request, source)
+    }
+
+    pub fn upsert_grpc_request(
+        &self,
+        grpc_request: &GrpcRequest,
+        source: &UpdateSource,
+    ) -> Result<GrpcRequest> {
+        self.upsert(grpc_request, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/http_requests.rs
+++ b/src-tauri/yaak-models/src/queries/http_requests.rs
@@ -0,0 +1,51 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{HttpRequest, HttpRequestIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_http_request(&self, id: &str) -> Result<Option<HttpRequest>> {
+        self.find_optional(HttpRequestIden::Id, id)
+    }
+
+    pub fn list_http_requests(&self, workspace_id: &str) -> Result<Vec<HttpRequest>> {
+        self.find_many(HttpRequestIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn delete_http_request(
+        &self,
+        m: &HttpRequest,
+        source: &UpdateSource,
+    ) -> Result<HttpRequest> {
+        self.delete_all_http_responses_for_request(m.id.as_str(), source)?;
+        self.delete(m, source)
+    }
+
+    pub fn delete_http_request_by_id(
+        &self,
+        id: &str,
+        source: &UpdateSource,
+    ) -> Result<HttpRequest> {
+        let http_request = self.get_http_request(id)?.unwrap();
+        self.delete_http_request(&http_request, source)
+    }
+
+    pub fn duplicate_http_request(
+        &self,
+        http_request: &HttpRequest,
+        source: &UpdateSource,
+    ) -> Result<HttpRequest> {
+        let mut http_request = http_request.clone();
+        http_request.id = "".to_string();
+        http_request.sort_priority = http_request.sort_priority + 0.001;
+        self.upsert(&http_request, source)
+    }
+
+    pub fn upsert_http_request(
+        &self,
+        http_request: &HttpRequest,
+        source: &UpdateSource,
+    ) -> Result<HttpRequest> {
+        self.upsert(http_request, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/http_responses.rs
+++ b/src-tauri/yaak-models/src/queries/http_responses.rs
@@ -0,0 +1,110 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{HttpResponse, HttpResponseIden, HttpResponseState};
+use crate::queries::base::MAX_HISTORY_ITEMS;
+use crate::queries_legacy::UpdateSource;
+use log::{debug, error};
+use sea_query::{Expr, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+use std::fs;
+
+impl<'a> DbContext<'a> {
+    pub fn get_http_response(&self, id: &str) -> Result<HttpResponse> {
+        self.find_one(HttpResponseIden::Id, id)
+    }
+
+    pub fn list_http_responses_for_request(
+        &self,
+        request_id: &str,
+        limit: Option<u64>,
+    ) -> Result<Vec<HttpResponse>> {
+        self.find_many(HttpResponseIden::RequestId, request_id, limit)
+    }
+
+    pub fn list_http_responses_for_workspace(
+        &self,
+        workspace_id: &str,
+        limit: Option<u64>,
+    ) -> Result<Vec<HttpResponse>> {
+        self.find_many(HttpResponseIden::WorkspaceId, workspace_id, limit)
+    }
+
+    pub fn delete_all_http_responses_for_request(
+        &self,
+        request_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let responses = self.list_http_responses_for_request(request_id, None)?;
+        for m in responses {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn delete_all_http_responses_for_workspace(
+        &self,
+        workspace_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let responses =
+            self.find_many::<HttpResponse>(HttpResponseIden::WorkspaceId, workspace_id, None)?;
+        for m in responses {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn delete_http_response(
+        &self,
+        http_response: &HttpResponse,
+        source: &UpdateSource,
+    ) -> Result<HttpResponse> {
+        // Delete the body file if it exists
+        if let Some(p) = http_response.body_path.clone() {
+            if let Err(e) = fs::remove_file(p) {
+                error!("Failed to delete body file: {}", e);
+            };
+        }
+
+        Ok(self.delete(http_response, source)?)
+    }
+
+    pub fn upsert_http_response(
+        &self,
+        http_response: &HttpResponse,
+        source: &UpdateSource,
+    ) -> Result<HttpResponse> {
+        let responses = self.list_http_responses_for_request(&http_response.request_id, None)?;
+
+        for m in responses.iter().skip(MAX_HISTORY_ITEMS - 1) {
+            debug!("Deleting old HTTP response {}", http_response.id);
+            self.delete_http_response(&m, source)?;
+        }
+
+        self.upsert(http_response, source)
+    }
+
+    pub fn cancel_pending_http_responses(&self) -> Result<()> {
+        let closed = serde_json::to_value(&HttpResponseState::Closed)?;
+        let (sql, params) = Query::update()
+            .table(HttpResponseIden::Table)
+            .values([(HttpResponseIden::State, closed.as_str().into())])
+            .cond_where(Expr::col(HttpResponseIden::State).ne(closed.as_str()))
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.prepare(sql.as_str())?;
+        stmt.execute(&*params.as_params())?;
+        Ok(())
+    }
+
+    pub fn update_http_response_if_id(
+        &self,
+        response: &HttpResponse,
+        source: &UpdateSource,
+    ) -> Result<HttpResponse> {
+        if response.id.is_empty() {
+            Ok(response.clone())
+        } else {
+            self.upsert(response, source)
+        }
+    }
+}
--- a/src-tauri/yaak-models/src/queries/key_values.rs
+++ b/src-tauri/yaak-models/src/queries/key_values.rs
@@ -0,0 +1,164 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{KeyValue, KeyValueIden};
+use crate::queries_legacy::{ModelChangeEvent, ModelPayload, UpdateSource};
+use log::error;
+use sea_query::Keyword::CurrentTimestamp;
+use sea_query::{Asterisk, Cond, Expr, OnConflict, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+
+impl<'a> DbContext<'a> {
+    pub fn list_key_values_raw(&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())?;
+        Ok(items.map(|v| v.unwrap()).collect())
+    }
+
+    pub fn get_key_value_string(&self, namespace: &str, key: &str, default: &str) -> String {
+        match self.get_key_value_raw(namespace, key) {
+            None => default.to_string(),
+            Some(v) => {
+                let result = serde_json::from_str(&v.value);
+                match result {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("Failed to parse string key value: {}", e);
+                        default.to_string()
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn get_key_value_int(&self, namespace: &str, key: &str, default: i32) -> i32 {
+        match self.get_key_value_raw(namespace, key) {
+            None => default.clone(),
+            Some(v) => {
+                let result = serde_json::from_str(&v.value);
+                match result {
+                    Ok(v) => v,
+                    Err(e) => {
+                        error!("Failed to parse int key value: {}", e);
+                        default.clone()
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn get_key_value_raw(&self, namespace: &str, key: &str) -> Option<KeyValue> {
+        let (sql, params) = Query::select()
+            .from(KeyValueIden::Table)
+            .column(Asterisk)
+            .cond_where(
+                Cond::all()
+                    .add(Expr::col(KeyValueIden::Namespace).eq(namespace))
+                    .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()
+    }
+
+    pub fn set_key_value_string(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: &str,
+        source: &UpdateSource,
+    ) -> (KeyValue, bool) {
+        let encoded = serde_json::to_string(&value).unwrap();
+        self.set_key_value_raw(namespace, key, &encoded, source)
+    }
+
+    pub fn set_key_value_int(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: i32,
+        source: &UpdateSource,
+    ) -> (KeyValue, bool) {
+        let encoded = serde_json::to_string(&value).unwrap();
+        self.set_key_value_raw(namespace, key, &encoded, source)
+    }
+
+    pub fn set_key_value_raw(
+        &self,
+        namespace: &str,
+        key: &str,
+        value: &str,
+        source: &UpdateSource,
+    ) -> (KeyValue, bool) {
+        let existing = self.get_key_value_raw(namespace, key);
+
+        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(),
+                namespace.into(),
+                key.into(),
+                value.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();
+
+        (m, existing.is_none())
+    }
+
+    pub fn delete_key_value(
+        &self,
+        namespace: &str,
+        key: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let kv = match self.get_key_value_raw(namespace, key) {
+            None => return Ok(()),
+            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();
+        Ok(())
+    }
+}
--- a/src-tauri/yaak-models/src/queries/mod.rs
+++ b/src-tauri/yaak-models/src/queries/mod.rs
@@ -0,0 +1,20 @@
+mod base;
+mod batch;
+mod cookie_jars;
+mod environments;
+mod folders;
+mod grpc_connections;
+mod grpc_events;
+mod grpc_requests;
+mod http_requests;
+mod http_responses;
+mod key_values;
+mod plugin_key_values;
+mod plugins;
+mod settings;
+mod sync_states;
+mod websocket_connections;
+mod websocket_events;
+mod websocket_requests;
+mod workspace_metas;
+mod workspaces;
--- a/src-tauri/yaak-models/src/queries/plugin_key_values.rs
+++ b/src-tauri/yaak-models/src/queries/plugin_key_values.rs
@@ -0,0 +1,79 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{PluginKeyValue, PluginKeyValueIden};
+use sea_query::Keyword::CurrentTimestamp;
+use sea_query::{Asterisk, Cond, Expr, OnConflict, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+
+impl<'a> DbContext<'a> {
+    pub fn get_plugin_key_value(&self, plugin_name: &str, key: &str) -> Option<PluginKeyValue> {
+        let (sql, params) = Query::select()
+            .from(PluginKeyValueIden::Table)
+            .column(Asterisk)
+            .cond_where(
+                Cond::all()
+                    .add(Expr::col(PluginKeyValueIden::PluginName).eq(plugin_name))
+                    .add(Expr::col(PluginKeyValueIden::Key).eq(key)),
+            )
+            .build_rusqlite(SqliteQueryBuilder);
+        self.conn.resolve().query_row(sql.as_str(), &*params.as_params(), |row| row.try_into()).ok()
+    }
+
+    pub fn set_plugin_key_value(
+        &self,
+        plugin_name: &str,
+        key: &str,
+        value: &str,
+    ) -> (PluginKeyValue, bool) {
+        let existing = self.get_plugin_key_value(plugin_name, key);
+
+        let (sql, params) = Query::insert()
+            .into_table(PluginKeyValueIden::Table)
+            .columns([
+                PluginKeyValueIden::CreatedAt,
+                PluginKeyValueIden::UpdatedAt,
+                PluginKeyValueIden::PluginName,
+                PluginKeyValueIden::Key,
+                PluginKeyValueIden::Value,
+            ])
+            .values_panic([
+                CurrentTimestamp.into(),
+                CurrentTimestamp.into(),
+                plugin_name.into(),
+                key.into(),
+                value.into(),
+            ])
+            .on_conflict(
+                OnConflict::new()
+                    .update_columns([PluginKeyValueIden::UpdatedAt, PluginKeyValueIden::Value])
+                    .to_owned(),
+            )
+            .returning_all()
+            .build_rusqlite(SqliteQueryBuilder);
+
+        let mut stmt =
+            self.conn.prepare(sql.as_str()).expect("Failed to prepare PluginKeyValue upsert");
+        let m: PluginKeyValue = stmt
+            .query_row(&*params.as_params(), |row| row.try_into())
+            .expect("Failed to upsert KeyValue");
+
+        (m, existing.is_none())
+    }
+
+    pub fn delete_plugin_key_value(&self, namespace: &str, key: &str) -> Result<bool> {
+        if let None = self.get_plugin_key_value(namespace, key) {
+            return Ok(false);
+        };
+
+        let (sql, params) = Query::delete()
+            .from_table(PluginKeyValueIden::Table)
+            .cond_where(
+                Cond::all()
+                    .add(Expr::col(PluginKeyValueIden::PluginName).eq(namespace))
+                    .add(Expr::col(PluginKeyValueIden::Key).eq(key)),
+            )
+            .build_rusqlite(SqliteQueryBuilder);
+        self.conn.execute(sql.as_str(), &*params.as_params())?;
+        Ok(true)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/plugins.rs
+++ b/src-tauri/yaak-models/src/queries/plugins.rs
@@ -0,0 +1,27 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{Plugin, PluginIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_plugin(&self, id: &str) -> Result<Plugin> {
+        self.find_one(PluginIden::Id, id)
+    }
+    
+    pub fn list_plugins(&self) -> Result<Vec<Plugin>> {
+        self.find_all()
+    }
+
+    pub fn delete_plugin(&self, plugin: &Plugin, source: &UpdateSource) -> Result<Plugin> {
+        self.delete(plugin, source)
+    }
+
+    pub fn delete_plugin_by_id(&self, id: &str, source: &UpdateSource) -> Result<Plugin> {
+        let plugin = self.get_plugin(id)?;
+        self.delete_plugin(&plugin, source)
+    }
+    
+    pub fn upsert_plugin(&self, plugin: &Plugin, source: &UpdateSource) -> Result<Plugin> {
+        self.upsert(plugin, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/settings.rs
+++ b/src-tauri/yaak-models/src/queries/settings.rs
@@ -0,0 +1,25 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{Settings, SettingsIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_or_create_settings(&self, source: &UpdateSource) -> Result<Settings> {
+        let id = "default";
+        if let Some(s) = self.find_optional::<Settings>(SettingsIden::Id, id)? {
+            return Ok(s);
+        };
+
+        self.upsert(
+            &Settings {
+                id: id.to_string(),
+                ..Default::default()
+            },
+            source,
+        )
+    }
+
+    pub fn upsert_settings(&self, settings: &Settings, source: &UpdateSource) -> Result<Settings> {
+        self.upsert(settings, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/sync_states.rs
+++ b/src-tauri/yaak-models/src/queries/sync_states.rs
@@ -0,0 +1,45 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{SyncState, SyncStateIden, UpsertModelInfo};
+use crate::queries_legacy::UpdateSource;
+use sea_query::{Asterisk, Cond, Expr, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+use std::path::Path;
+
+impl<'a> DbContext<'a> {
+    pub fn get_sync_state(&self, id: &str) -> Result<SyncState> {
+        self.find_one(SyncStateIden::Id, id)
+    }
+
+    pub fn upsert_sync_state(&self, sync_state: &SyncState) -> Result<SyncState> {
+        self.upsert(sync_state, &UpdateSource::Sync)
+    }
+
+    pub fn list_sync_states_for_workspace(
+        &self,
+        workspace_id: &str,
+        sync_dir: &Path,
+    ) -> Result<Vec<SyncState>> {
+        let (sql, params) = Query::select()
+            .from(SyncStateIden::Table)
+            .column(Asterisk)
+            .cond_where(
+                Cond::all()
+                    .add(Expr::col(SyncStateIden::WorkspaceId).eq(workspace_id))
+                    .add(Expr::col(SyncStateIden::SyncDir).eq(sync_dir.to_string_lossy())),
+            )
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.prepare(sql.as_str())?;
+        let items = stmt.query_map(&*params.as_params(), SyncState::from_row)?;
+        Ok(items.map(|v| v.unwrap()).collect())
+    }
+
+    pub fn delete_sync_state(&self, sync_state: &SyncState) -> Result<SyncState> {
+        self.delete(sync_state, &UpdateSource::Sync)
+    }
+
+    pub fn delete_sync_state_by_id(&self, id: &str) -> Result<SyncState> {
+        let sync_state = self.get_sync_state(id)?;
+        self.delete_sync_state(&sync_state)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/websocket_connections.rs
+++ b/src-tauri/yaak-models/src/queries/websocket_connections.rs
@@ -0,0 +1,97 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{WebsocketConnection, WebsocketConnectionIden, WebsocketConnectionState};
+use crate::queries::base::MAX_HISTORY_ITEMS;
+use crate::queries_legacy::UpdateSource;
+use log::debug;
+use sea_query::{Expr, Query, SqliteQueryBuilder};
+use sea_query_rusqlite::RusqliteBinder;
+
+impl<'a> DbContext<'a> {
+    pub fn get_websocket_connection(&self, id: &str) -> Result<WebsocketConnection> {
+        self.find_one(WebsocketConnectionIden::Id, id)
+    }
+
+    pub fn delete_all_websocket_connections_for_request(
+        &self,
+        request_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let responses = self.list_websocket_connections_for_request(request_id)?;
+        for m in responses {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn delete_all_websocket_connections_for_workspace(
+        &self,
+        workspace_id: &str,
+        source: &UpdateSource,
+    ) -> Result<()> {
+        let responses = self.list_websocket_connections_for_workspace(workspace_id)?;
+        for m in responses {
+            self.delete(&m, source)?;
+        }
+        Ok(())
+    }
+
+    pub fn list_websocket_connections_for_workspace(
+        &self,
+        workspace_id: &str,
+    ) -> Result<Vec<WebsocketConnection>> {
+        self.find_many(WebsocketConnectionIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn list_websocket_connections_for_request(
+        &self,
+        request_id: &str,
+    ) -> Result<Vec<WebsocketConnection>> {
+        self.find_many(WebsocketConnectionIden::RequestId, request_id, None)
+    }
+
+    pub fn delete_websocket_connection(
+        &self,
+        websocket_connection: &WebsocketConnection,
+        source: &UpdateSource,
+    ) -> Result<WebsocketConnection> {
+        self.delete(websocket_connection, source)
+    }
+
+    pub fn delete_websocket_connection_by_id(
+        &self,
+        id: &str,
+        source: &UpdateSource,
+    ) -> Result<WebsocketConnection> {
+        let websocket_connection = self.get_websocket_connection(id)?;
+        self.delete_websocket_connection(&websocket_connection, source)
+    }
+
+    pub fn upsert_websocket_connection(
+        &self,
+        websocket_connection: &WebsocketConnection,
+        source: &UpdateSource,
+    ) -> Result<WebsocketConnection> {
+        let connections =
+            self.list_websocket_connections_for_request(&websocket_connection.request_id)?;
+
+        for m in connections.iter().skip(MAX_HISTORY_ITEMS - 1) {
+            debug!("Deleting old websocket connection {}", websocket_connection.id);
+            self.delete_websocket_connection(&m, source)?;
+        }
+
+        self.upsert(websocket_connection, source)
+    }
+
+    pub fn cancel_pending_websocket_connections(&self) -> Result<()> {
+        let closed = serde_json::to_value(&WebsocketConnectionState::Closed)?;
+        let (sql, params) = Query::update()
+            .table(WebsocketConnectionIden::Table)
+            .values([(WebsocketConnectionIden::State, closed.as_str().into())])
+            .cond_where(Expr::col(WebsocketConnectionIden::State).ne(closed.as_str()))
+            .build_rusqlite(SqliteQueryBuilder);
+        let mut stmt = self.conn.prepare(sql.as_str())?;
+        stmt.execute(&*params.as_params())?;
+        Ok(())
+    }
+}
--- a/src-tauri/yaak-models/src/queries/websocket_events.rs
+++ b/src-tauri/yaak-models/src/queries/websocket_events.rs
@@ -0,0 +1,25 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{
+    WebsocketEvent,
+    WebsocketEventIden,
+};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_websocket_event(&self, id: &str) -> Result<WebsocketEvent> {
+        self.find_one(WebsocketEventIden::Id, id)
+    }
+
+    pub fn list_websocket_events(&self, connection_id: &str) -> Result<Vec<WebsocketEvent>> {
+        self.find_many(WebsocketEventIden::ConnectionId, connection_id, None)
+    }
+
+    pub fn upsert_websocket_event(
+        &self,
+        websocket_event: &WebsocketEvent,
+        source: &UpdateSource,
+    ) -> Result<WebsocketEvent> {
+        self.upsert(websocket_event, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/websocket_requests.rs
+++ b/src-tauri/yaak-models/src/queries/websocket_requests.rs
@@ -0,0 +1,51 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{WebsocketRequest, WebsocketRequestIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_websocket_request(&self, id: &str) -> Result<Option<WebsocketRequest>> {
+        self.find_optional(WebsocketRequestIden::Id, id)
+    }
+
+    pub fn list_websocket_requests(&self, workspace_id: &str) -> Result<Vec<WebsocketRequest>> {
+        self.find_many(WebsocketRequestIden::WorkspaceId, workspace_id, None)
+    }
+
+    pub fn delete_websocket_request(
+        &self,
+        websocket_request: &WebsocketRequest,
+        source: &UpdateSource,
+    ) -> Result<WebsocketRequest> {
+        self.delete_all_websocket_connections_for_request(websocket_request.id.as_str(), source)?;
+        self.delete(websocket_request, source)
+    }
+
+    pub fn delete_websocket_request_by_id(
+        &self,
+        id: &str,
+        source: &UpdateSource,
+    ) -> Result<WebsocketRequest> {
+        let request = self.get_websocket_request(id)?.unwrap();
+        self.delete_websocket_request(&request, source)
+    }
+
+    pub fn duplicate_websocket_request(
+        &self,
+        websocket_request: &WebsocketRequest,
+        source: &UpdateSource,
+    ) -> Result<WebsocketRequest> {
+        let mut websocket_request = websocket_request.clone();
+        websocket_request.id = "".to_string();
+        websocket_request.sort_priority = websocket_request.sort_priority + 0.001;
+        self.upsert(&websocket_request, source)
+    }
+
+    pub fn upsert_websocket_request(
+        &self,
+        websocket_request: &WebsocketRequest,
+        source: &UpdateSource,
+    ) -> Result<WebsocketRequest> {
+        self.upsert(websocket_request, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/workspace_metas.rs
+++ b/src-tauri/yaak-models/src/queries/workspace_metas.rs
@@ -0,0 +1,36 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{Workspace, WorkspaceMeta, WorkspaceMetaIden};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_workspace_meta(&self, workspace: &Workspace) -> Result<Option<WorkspaceMeta>> {
+        self.find_optional(WorkspaceMetaIden::WorkspaceId, &workspace.id)
+    }
+
+    pub fn get_or_create_workspace_meta(
+        &self,
+        workspace: &Workspace,
+        source: &UpdateSource,
+    ) -> Result<WorkspaceMeta> {
+        let workspace_meta = self.get_workspace_meta(workspace)?;
+        if let Some(workspace_meta) = workspace_meta {
+            return Ok(workspace_meta);
+        }
+
+        let workspace_meta = WorkspaceMeta {
+            workspace_id: workspace.to_owned().id,
+            ..Default::default()
+        };
+
+        self.upsert_workspace_meta(&workspace_meta, source)
+    }
+
+    pub fn upsert_workspace_meta(
+        &self,
+        workspace_meta: &WorkspaceMeta,
+        source: &UpdateSource,
+    ) -> Result<WorkspaceMeta> {
+        self.upsert(workspace_meta, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries/workspaces.rs
+++ b/src-tauri/yaak-models/src/queries/workspaces.rs
@@ -0,0 +1,52 @@
+use crate::error::Result;
+use crate::manager::DbContext;
+use crate::models::{
+    Folder, FolderIden, GrpcRequest, GrpcRequestIden, HttpRequest, HttpRequestIden,
+    WebsocketRequest, WebsocketRequestIden, Workspace, WorkspaceIden,
+};
+use crate::queries_legacy::UpdateSource;
+
+impl<'a> DbContext<'a> {
+    pub fn get_workspace(&self, id: &str) -> Result<Workspace> {
+        self.find_one(WorkspaceIden::Id, id)
+    }
+
+    pub fn list_workspaces(&self) -> Result<Vec<Workspace>> {
+        self.find_all()
+    }
+
+    pub fn delete_workspace(
+        &self,
+        workspace: &Workspace,
+        source: &UpdateSource,
+    ) -> Result<Workspace> {
+        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)
+    }
+
+    pub fn delete_workspace_by_id(&self, id: &str, source: &UpdateSource) -> Result<Workspace> {
+        let workspace = self.get_workspace(id)?;
+        self.delete_workspace(&workspace, source)
+    }
+
+    pub fn upsert_workspace(&self, w: &Workspace, source: &UpdateSource) -> Result<Workspace> {
+        self.upsert(w, source)
+    }
+}
--- a/src-tauri/yaak-models/src/queries_legacy.rs
+++ b/src-tauri/yaak-models/src/queries_legacy.rs
@@ -0,0 +1,150 @@
+use crate::error::Result;
+use crate::manager::QueryManagerExt;
+use crate::models::{AnyModel, Environment, Folder, GrpcRequest, HttpRequest, ModelType, WebsocketRequest, Workspace, WorkspaceIden};
+use chrono::{NaiveDateTime, Utc};
+use log::warn;
+use nanoid::nanoid;
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, Listener, Runtime, WebviewWindow};
+use ts_rs::TS;
+
+pub fn generate_model_id(model: ModelType) -> String {
+    let id = generate_id();
+    format!("{}_{}", model.id_prefix(), id)
+}
+
+pub fn generate_id() -> String {
+    let alphabet: [char; 57] = [
+        '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j',
+        'k', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C',
+        'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+        'X', 'Y', 'Z',
+    ];
+
+    nanoid!(10, &alphabet)
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(export, export_to = "gen_models.ts")]
+pub struct ModelPayload {
+    pub model: AnyModel,
+    pub update_source: UpdateSource,
+    pub change: ModelChangeEvent,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "gen_models.ts")]
+pub enum ModelChangeEvent {
+    Upsert,
+    Delete,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, TS)]
+#[serde(rename_all = "snake_case", tag = "type")]
+#[ts(export, export_to = "gen_models.ts")]
+pub enum UpdateSource {
+    Sync,
+    Window { label: String },
+    Plugin,
+    Background,
+    Import,
+}
+
+impl UpdateSource {
+    pub fn from_window<R: Runtime>(window: &WebviewWindow<R>) -> Self {
+        Self::Window {
+            label: window.label().to_string(),
+        }
+    }
+}
+
+pub fn listen_to_model_delete<F, R>(app_handle: &AppHandle<R>, handler: F)
+where
+    F: Fn(ModelPayload) + Send + 'static,
+    R: Runtime,
+{
+    app_handle.listen_any("deleted_model", move |e| {
+        match serde_json::from_str(e.payload()) {
+            Ok(payload) => handler(payload),
+            Err(e) => {
+                warn!("Failed to deserialize deleted model {}", e);
+                return;
+            }
+        };
+    });
+}
+
+pub fn listen_to_model_upsert<F, R>(app_handle: &AppHandle<R>, handler: F)
+where
+    F: Fn(ModelPayload) + Send + 'static,
+    R: Runtime,
+{
+    app_handle.listen_any("upserted_model", move |e| {
+        match serde_json::from_str(e.payload()) {
+            Ok(payload) => handler(payload),
+            Err(e) => {
+                warn!("Failed to deserialize upserted model {}", e);
+                return;
+            }
+        };
+    });
+}
+
+#[derive(Default, Debug, Deserialize, Serialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct WorkspaceExport {
+    pub yaak_version: String,
+    pub yaak_schema: i64,
+    pub timestamp: NaiveDateTime,
+    pub resources: BatchUpsertResult,
+}
+
+#[derive(Default, Debug, Deserialize, Serialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct BatchUpsertResult {
+    pub workspaces: Vec<Workspace>,
+    pub environments: Vec<Environment>,
+    pub folders: Vec<Folder>,
+    pub http_requests: Vec<HttpRequest>,
+    pub grpc_requests: Vec<GrpcRequest>,
+    pub websocket_requests: Vec<WebsocketRequest>,
+}
+
+pub async fn get_workspace_export_resources<R: Runtime>(
+    app_handle: &AppHandle<R>,
+    workspace_ids: Vec<&str>,
+    include_environments: bool,
+) -> Result<WorkspaceExport> {
+    let mut data = WorkspaceExport {
+        yaak_version: app_handle.package_info().version.clone().to_string(),
+        yaak_schema: 3,
+        timestamp: Utc::now().naive_utc(),
+        resources: BatchUpsertResult {
+            workspaces: Vec::new(),
+            environments: Vec::new(),
+            folders: Vec::new(),
+            http_requests: Vec::new(),
+            grpc_requests: Vec::new(),
+            websocket_requests: Vec::new(),
+        },
+    };
+
+    let db = app_handle.queries().connect().await?;
+    for workspace_id in workspace_ids {
+        data.resources.workspaces.push(db.find_one(WorkspaceIden::Id, workspace_id)?);
+        data.resources.environments.append(&mut db.list_environments(workspace_id)?);
+        data.resources.folders.append(&mut db.list_folders(workspace_id)?);
+        data.resources.http_requests.append(&mut db.list_http_requests(workspace_id)?);
+        data.resources.grpc_requests.append(&mut db.list_grpc_requests(workspace_id)?);
+        data.resources.websocket_requests.append(&mut db.list_websocket_requests(workspace_id)?);
+    }
+
+    // Nuke environments if we don't want them
+    if !include_environments {
+        data.resources.environments.clear();
+    }
+
+    Ok(data)
+}